AuroraMiddleware/SPIRV-Cross-Vulnerable
1
0
Fork 0
mirror of https://github.com/KhronosGroup/SPIRV-Cross.git synced 2024-11-09 13:50:05 +00:00
Code Issues Projects Releases Wiki Activity
main
SPIRV-Cross-Vulnerable/spirv_glsl.cpp

19169 lines
617 KiB
C++
Raw Permalink Normal View History

Initial commit.
2016-03-02 17:09:16 +00:00
/*
meta: Update copyright headers to 2021.
2021-01-14 15:07:49 +00:00
* Copyright 2015-2021 Arm Limited
Finish adding SPDX tags and setup a reuse checked in Github Actions CI
2021-05-08 08:47:48 +00:00
* SPDX-License-Identifier: Apache-2.0 OR MIT
Initial commit.
2016-03-02 17:09:16 +00:00
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
Add MIT dual license for the SPIRV-Cross API.
2020-11-25 14:22:08 +00:00
/*
* At your option, you may choose to accept this material under either:
* 1. The Apache License, Version 2.0, found at <http://www.apache.org/licenses/LICENSE-2.0>, or
* 2. The MIT License, found at <http://opensource.org/licenses/MIT>.
*/
Rename project to SPIRV-Cross. Rename to coincide with moving the project to KhronosGroup.
2016-04-04 07:36:04 +00:00
#include "spirv_glsl.hpp"
Initial commit.
2016-03-02 17:09:16 +00:00
#include "GLSL.std.450.h"
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
#include "spirv_common.hpp"
Initial commit.
2016-03-02 17:09:16 +00:00
#include <algorithm>
#include <assert.h>
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
#include <cmath>
Workaround NOMINMAX issues on Windows. ::max() can be overridden if you forget NOMINMAX on Windows. Hardcode literals instead. UINT32_MAX also requires weird macros in C++.
2018-07-16 22:10:12 +00:00
#include <limits>
Replace locale handling. We were using std::locale::global() to force a C locale which is not safe when SPIRV-Cross is used in a multi-threaded environment. To fix this, we could tap into various per-platform specific locale handling to get safe thread-local locales, but since locales only affect the decimal point in floats, we simply query the locale instead and do the necessary radix replacement ourselves, without touching the locale. This should be much safer and cleaner than the alternative.
2019-02-28 10:26:26 +00:00
#include <locale.h>
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
#include <utility>
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
#include <array>
Initial commit.
2016-03-02 17:09:16 +00:00
Use nl_langinfo on POSIX systems. localeconv is not MT-safe.
2019-02-28 10:51:08 +00:00
#ifndef _WIN32
#include <langinfo.h>
#endif
#include <locale.h>
Initial commit.
2016-03-02 17:09:16 +00:00
using namespace spv;
Add an option to override the namespace used for spirv_cross. This is a pragmatic trick to avoid symbol collision where a project links against SPIRV-Cross statically, while linking to other projects which also use SPIRV-Cross statically. We can end up with very awkward symbol collisions which can resolve themselves silently because SPIRV-Cross is pulled in as necessary. To fix this, we must use different symbols and embed two copies of SPIRV-Cross in this scenario, now with different namespaces, which in turn leads to different symbols.
2019-03-29 09:29:44 +00:00
using namespace SPIRV_CROSS_NAMESPACE;
Initial commit.
2016-03-02 17:09:16 +00:00
using namespace std;
Handle edge cases in OpCopyMemory. Implement this by synthesizing an OpLoad/OpStore pair instead.
2021-03-08 13:09:32 +00:00
enum ExtraSubExpressionType
{
// Create masks above any legal ID range to allow multiple address spaces into the extra_sub_expressions map.
EXTRA_SUB_EXPRESSION_TYPE_STREAM_OFFSET = 0x10000000,
EXTRA_SUB_EXPRESSION_TYPE_AUX = 0x20000000
};
Be a bit smarter about uint on legacy targets. Allow constants (array sizes for example), but using unsigned opcodes, and unsigned-specific opcodes is a problem.
2018-04-17 12:56:49 +00:00
static bool is_unsigned_opcode(Op op)
{
// Don't have to be exhaustive, only relevant for legacy target checking ...
switch (op)
{
case OpShiftRightLogical:
case OpUGreaterThan:
case OpUGreaterThanEqual:
case OpULessThan:
case OpULessThanEqual:
case OpUConvert:
case OpUDiv:
case OpUMod:
case OpUMulExtended:
case OpConvertUToF:
case OpConvertFToU:
return true;
default:
return false;
}
}
static bool is_unsigned_glsl_opcode(GLSLstd450 op)
{
// Don't have to be exhaustive, only relevant for legacy target checking ...
switch (op)
{
case GLSLstd450UClamp:
case GLSLstd450UMin:
case GLSLstd450UMax:
case GLSLstd450FindUMsb:
return true;
default:
return false;
}
}
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
static bool packing_is_vec4_padded(BufferPackingStandard packing)
{
switch (packing)
{
case BufferPackingHLSLCbuffer:
case BufferPackingHLSLCbufferPackOffset:
case BufferPackingStd140:
case BufferPackingStd140EnhancedLayout:
return true;
default:
return false;
}
}
static bool packing_is_hlsl(BufferPackingStandard packing)
{
switch (packing)
{
case BufferPackingHLSLCbuffer:
case BufferPackingHLSLCbufferPackOffset:
return true;
default:
return false;
}
}
static bool packing_has_flexible_offset(BufferPackingStandard packing)
{
switch (packing)
{
case BufferPackingStd140:
case BufferPackingStd430:
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
case BufferPackingScalar:
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
case BufferPackingHLSLCbuffer:
return false;
default:
return true;
}
}
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
static bool packing_is_scalar(BufferPackingStandard packing)
{
switch (packing)
{
case BufferPackingScalar:
case BufferPackingScalarEnhancedLayout:
return true;
default:
return false;
}
}
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
static BufferPackingStandard packing_to_substruct_packing(BufferPackingStandard packing)
{
switch (packing)
{
case BufferPackingStd140EnhancedLayout:
return BufferPackingStd140;
case BufferPackingStd430EnhancedLayout:
return BufferPackingStd430;
case BufferPackingHLSLCbufferPackOffset:
return BufferPackingHLSLCbuffer;
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
case BufferPackingScalarEnhancedLayout:
return BufferPackingScalar;
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
default:
return packing;
}
}
Replace locale handling. We were using std::locale::global() to force a C locale which is not safe when SPIRV-Cross is used in a multi-threaded environment. To fix this, we could tap into various per-platform specific locale handling to get safe thread-local locales, but since locales only affect the decimal point in floats, we simply query the locale instead and do the necessary radix replacement ourselves, without touching the locale. This should be much safer and cleaner than the alternative.
2019-02-28 10:26:26 +00:00
void CompilerGLSL::init()
{
if (ir.source.known)
{
options.es = ir.source.es;
options.version = ir.source.version;
}
// Query the locale to see what the decimal point is.
// We'll rely on fixing it up ourselves in the rare case we have a comma-as-decimal locale
// rather than setting locales ourselves. Settings locales in a safe and isolated way is rather
// tricky.
Use nl_langinfo on POSIX systems. localeconv is not MT-safe.
2019-02-28 10:51:08 +00:00
#ifdef _WIN32
// On Windows, localeconv uses thread-local storage, so it should be fine.
const struct lconv *conv = localeconv();
if (conv && conv->decimal_point)
current_locale_radix_character = *conv->decimal_point;
Fix build on Android API < 26.
2019-03-18 09:13:33 +00:00
#elif defined(__ANDROID__) && __ANDROID_API__ < 26
// nl_langinfo is not supported on this platform, fall back to the worse alternative.
const struct lconv *conv = localeconv();
if (conv && conv->decimal_point)
current_locale_radix_character = *conv->decimal_point;
Use nl_langinfo on POSIX systems. localeconv is not MT-safe.
2019-02-28 10:51:08 +00:00
#else
// localeconv, the portable function is not MT safe ...
Use RADIXCHAR, which is the portable variant of DECIMAL_POINT.
2019-02-28 11:32:52 +00:00
const char *decimal_point = nl_langinfo(RADIXCHAR);
Use nl_langinfo on POSIX systems. localeconv is not MT-safe.
2019-02-28 10:51:08 +00:00
if (decimal_point && *decimal_point != '\0')
current_locale_radix_character = *decimal_point;
#endif
Replace locale handling. We were using std::locale::global() to force a C locale which is not safe when SPIRV-Cross is used in a multi-threaded environment. To fix this, we could tap into various per-platform specific locale handling to get safe thread-local locales, but since locales only affect the decimal point in floats, we simply query the locale instead and do the necessary radix replacement ourselves, without touching the locale. This should be much safer and cleaner than the alternative.
2019-02-28 10:26:26 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
static const char *to_pls_layout(PlsFormat format)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (format)
{
case PlsR11FG11FB10F:
return "layout(r11f_g11f_b10f) ";
case PlsR32F:
return "layout(r32f) ";
case PlsRG16F:
return "layout(rg16f) ";
case PlsRGB10A2:
return "layout(rgb10_a2) ";
case PlsRGBA8:
return "layout(rgba8) ";
case PlsRG16:
return "layout(rg16) ";
case PlsRGBA8I:
return "layout(rgba8i)";
case PlsRG16I:
return "layout(rg16i) ";
case PlsRGB10A2UI:
return "layout(rgb10_a2ui) ";
case PlsRGBA8UI:
return "layout(rgba8ui) ";
case PlsRG16UI:
return "layout(rg16ui) ";
case PlsR32UI:
return "layout(r32ui) ";
default:
return "";
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
static std::pair<spv::Op, SPIRType::BaseType> pls_format_to_basetype(PlsFormat format)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (format)
{
default:
case PlsR11FG11FB10F:
case PlsR32F:
case PlsRG16F:
case PlsRGB10A2:
case PlsRGBA8:
case PlsRG16:
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
return std::make_pair(spv::OpTypeFloat, SPIRType::Float);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case PlsRGBA8I:
case PlsRG16I:
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
return std::make_pair(spv::OpTypeInt, SPIRType::Int);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case PlsRGB10A2UI:
case PlsRGBA8UI:
case PlsRG16UI:
case PlsR32UI:
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
return std::make_pair(spv::OpTypeInt, SPIRType::UInt);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
static uint32_t pls_format_to_components(PlsFormat format)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (format)
{
default:
case PlsR32F:
case PlsR32UI:
return 1;
case PlsRG16F:
case PlsRG16:
case PlsRG16UI:
case PlsRG16I:
return 2;
case PlsR11FG11FB10F:
return 3;
case PlsRGB10A2:
case PlsRGBA8:
case PlsRGBA8I:
case PlsRGB10A2UI:
case PlsRGBA8UI:
return 4;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
MSL: Deal with packing vectors for vertex input/fragment output.
2020-01-07 13:05:55 +00:00
const char *CompilerGLSL::vector_swizzle(int vecsize, int index)
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
{
Run format_all.sh.
2019-06-21 14:02:22 +00:00
static const char *const swizzle[4][4] = {
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
{ ".x", ".y", ".z", ".w" },
{ ".xy", ".yz", ".zw", nullptr },
{ ".xyz", ".yzw", nullptr, nullptr },
Workaround GCC 9 bug.
2019-06-24 08:17:25 +00:00
#if defined(__GNUC__) && (__GNUC__ == 9)
// This works around a GCC 9 bug, see details in https://gcc.gnu.org/bugzilla/show_bug.cgi?id=90947.
// This array ends up being compiled as all nullptrs, tripping the assertions below.
{ "", nullptr, nullptr, "$" },
#else
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
{ "", nullptr, nullptr, nullptr },
Workaround GCC 9 bug.
2019-06-24 08:17:25 +00:00
#endif
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
};
assert(vecsize >= 1 && vecsize <= 4);
assert(index >= 0 && index < 4);
assert(swizzle[vecsize - 1][index]);
return swizzle[vecsize - 1][index];
}
Rework how loop iteration counts are validated. Introduces an idea of a recompilation making forward progress. There are some extreme edge cases where we need more than 3 loops, but only allow this in specific circumstances where we can reason about forward progress being made.
2022-01-17 13:12:01 +00:00
void CompilerGLSL::reset(uint32_t iteration_count)
{
// Sanity check the iteration count to be robust against a certain class of bugs where
// we keep forcing recompilations without making clear forward progress.
// In buggy situations we will loop forever, or loop for an unbounded number of iterations.
// Certain types of recompilations are considered to make forward progress,
// but in almost all situations, we'll never see more than 3 iterations.
// It is highly context-sensitive when we need to force recompilation,
// and it is not practical with the current architecture
// to resolve everything up front.
Add debug option to modify maximum number of compile iterations. Should be seen as a hack, but it's pragmatic in some scenarios.
2022-02-16 11:12:27 +00:00
if (iteration_count >= options.force_recompile_max_debug_iterations && !is_force_recompile_forward_progress)
SPIRV_CROSS_THROW("Maximum compilation loops detected and no forward progress was made. Must be a SPIRV-Cross bug!");
Rework how loop iteration counts are validated. Introduces an idea of a recompilation making forward progress. There are some extreme edge cases where we need more than 3 loops, but only allow this in specific circumstances where we can reason about forward progress being made.
2022-01-17 13:12:01 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// We do some speculative optimizations which should pretty much always work out,
// but just in case the SPIR-V is rather weird, recompile until it's happy.
// This typically only means one extra pass.
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
clear_force_recompile();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Clear invalid expression tracking.
invalid_expressions.clear();
Attempt more optimal codegen for OpCompositeInsert. Speculate that we can modify the SSA value in-place. As long as it is not used after the modify, this is fine. Also need to make sure we don't attempt to RMW something that is impossible to modify.
2022-05-18 10:26:20 +00:00
composite_insert_overwritten.clear();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
current_function = nullptr;
// Clear temporary usage tracking.
expression_usage_counts.clear();
forwarded_temporaries.clear();
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
suppressed_usage_tracking.clear();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Ensure that we declare phi-variable copies even if the original declaration isn't deferred
There are occasions where phi-variable copies are introduced for original variables which are fully declared, which coud result in the phi-variable never being declared and the shader not compiling, so declare the phi-variables when this happens. Change made in two parts. 1. Ensure that we declare phi-variable copies even if the original declaration isn't deferred. 2. Only flush phi variables once, avoids duplicate definitions.
2019-08-14 15:04:58 +00:00
flushed_phi_variables.clear();
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Handle multiple breaks out of switches. Use a switch stack instead.
2022-07-22 13:29:48 +00:00
current_emitting_switch_stack.clear();
GLSL: Fix block name shenanigans in edge cases. When we force recompile, the old var.self name we used as a fallback name might have been disturbed, so we should recover certain names back to their original form in case we are forced to take a recompile to make the naming algorithm more deterministic.
2019-02-13 15:39:59 +00:00
reset_name_caches();
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRFunction>([&](uint32_t, SPIRFunction &func) {
func.active = false;
func.flush_undeclared = true;
});
Run format_all.sh.
2019-01-11 11:56:00 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) { var.dependees.clear(); });
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
ir.reset_all_of_type<SPIRExpression>();
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.reset_all_of_type<SPIRAccessChain>();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement_count = 0;
indent = 0;
Implement context-sensitive expression read tracking. When inside a loop, treat any read of outer expressions to happen multiple times, forcing a temporary of said outer expressions. This avoids the problem where we can end up relying on loop-invariant code motion to happen in the compiler when converting optimized shaders.
2020-06-29 10:20:35 +00:00
current_loop_level = 0;
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::remap_pls_variables()
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (auto &input : pls_inputs)
{
auto &var = get<SPIRVariable>(input.id);
bool input_is_target = false;
if (var.storage == StorageClassUniformConstant)
{
auto &type = get<SPIRType>(var.basetype);
input_is_target = type.image.dim == DimSubpassData;
}
if (var.storage != StorageClassInput && !input_is_target)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Can only use in and target variables for PLS inputs.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
var.remapped_variable = true;
}
for (auto &output : pls_outputs)
{
auto &var = get<SPIRVariable>(output.id);
if (var.storage != StorageClassOutput)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Can only use out variables for PLS outputs.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
var.remapped_variable = true;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
GLSL: Implement noncoherent framebuffer fetch.
2021-05-21 12:21:13 +00:00
void CompilerGLSL::remap_ext_framebuffer_fetch(uint32_t input_attachment_index, uint32_t color_location, bool coherent)
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
{
subpass_to_framebuffer_fetch_attachment.push_back({ input_attachment_index, color_location });
GLSL: Implement noncoherent framebuffer fetch.
2021-05-21 12:21:13 +00:00
inout_color_attachments.push_back({ color_location, coherent });
}
bool CompilerGLSL::location_is_framebuffer_fetch(uint32_t location) const
{
return std::find_if(begin(inout_color_attachments), end(inout_color_attachments),
[&](const std::pair<uint32_t, bool> &elem) {
return elem.first == location;
}) != end(inout_color_attachments);
}
bool CompilerGLSL::location_is_non_coherent_framebuffer_fetch(uint32_t location) const
{
return std::find_if(begin(inout_color_attachments), end(inout_color_attachments),
[&](const std::pair<uint32_t, bool> &elem) {
return elem.first == location && !elem.second;
}) != end(inout_color_attachments);
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
}
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
void CompilerGLSL::find_static_extensions()
{
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRType>([&](uint32_t, const SPIRType &type) {
if (type.basetype == SPIRType::Double)
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
{
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (options.es)
SPIRV_CROSS_THROW("FP64 not supported in ES profile.");
if (!options.es && options.version < 400)
require_extension_internal("GL_ARB_gpu_shader_fp64");
}
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
else if (type.basetype == SPIRType::Int64 || type.basetype == SPIRType::UInt64)
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
{
GLSL: Add more extension ladder fallbacks for unusual integer sizes.
2022-06-07 13:39:37 +00:00
if (options.es && options.version < 310) // GL_NV_gpu_shader5 fallback requires 310.
SPIRV_CROSS_THROW("64-bit integers not supported in ES profile before version 310.");
require_extension_internal("GL_ARB_gpu_shader_int64");
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
}
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
else if (type.basetype == SPIRType::Half)
{
require_extension_internal("GL_EXT_shader_explicit_arithmetic_types_float16");
if (options.vulkan_semantics)
require_extension_internal("GL_EXT_shader_16bit_storage");
}
else if (type.basetype == SPIRType::SByte || type.basetype == SPIRType::UByte)
{
require_extension_internal("GL_EXT_shader_explicit_arithmetic_types_int8");
if (options.vulkan_semantics)
require_extension_internal("GL_EXT_shader_8bit_storage");
}
else if (type.basetype == SPIRType::Short || type.basetype == SPIRType::UShort)
{
require_extension_internal("GL_EXT_shader_explicit_arithmetic_types_int16");
if (options.vulkan_semantics)
require_extension_internal("GL_EXT_shader_16bit_storage");
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
auto &execution = get_entry_point();
switch (execution.model)
{
case ExecutionModelGLCompute:
if (!options.es && options.version < 430)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_compute_shader");
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
if (options.es && options.version < 310)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("At least ESSL 3.10 required for compute shaders.");
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
break;
case ExecutionModelGeometry:
if (options.es && options.version < 320)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_EXT_geometry_shader");
Geometry shader core since GLSL 150
2017-06-17 01:06:46 +00:00
if (!options.es && options.version < 150)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_geometry_shader4");
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeInvocations) && execution.invocations != 1)
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
{
// Instanced GS is part of 400 core or this extension.
if (!options.es && options.version < 400)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_gpu_shader5");
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
}
break;
case ExecutionModelTessellationEvaluation:
case ExecutionModelTessellationControl:
if (options.es && options.version < 320)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_EXT_tessellation_shader");
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
if (!options.es && options.version < 400)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_tessellation_shader");
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
break;
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
case ExecutionModelRayGenerationKHR:
case ExecutionModelIntersectionKHR:
case ExecutionModelAnyHitKHR:
case ExecutionModelClosestHitKHR:
case ExecutionModelMissKHR:
case ExecutionModelCallableKHR:
// NV enums are aliases.
Add "GL_NV_ray_tracing" extension to output when ray tracing execution model is found
2019-03-25 14:06:01 +00:00
if (options.es || options.version < 460)
SPIRV_CROSS_THROW("Ray tracing shaders require non-es profile with version 460 or above.");
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Ray tracing requires Vulkan semantics.");
// Need to figure out if we should target KHR or NV extension based on capabilities.
for (auto &cap : ir.declared_capabilities)
{
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
if (cap == CapabilityRayTracingKHR || cap == CapabilityRayQueryKHR ||
cap == CapabilityRayTraversalPrimitiveCullingKHR)
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
{
ray_tracing_is_khr = true;
break;
}
}
if (ray_tracing_is_khr)
{
// In KHR ray tracing we pass payloads by pointer instead of location,
// so make sure we assign locations properly.
ray_tracing_khr_fixup_locations();
require_extension_internal("GL_EXT_ray_tracing");
}
else
require_extension_internal("GL_NV_ray_tracing");
Add "GL_NV_ray_tracing" extension to output when ray tracing execution model is found
2019-03-25 14:06:01 +00:00
break;
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
case ExecutionModelMeshEXT:
GLSL: Implement task shaders. Due to bugged glslang / spirv-tools w.r.t. terminator instructions, add a hack to ignore invalid SPIR-V for the time being.
2022-09-05 10:31:22 +00:00
case ExecutionModelTaskEXT:
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if (options.es || options.version < 450)
SPIRV_CROSS_THROW("Mesh shaders require GLSL 450 or above.");
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Mesh shaders require Vulkan semantics.");
require_extension_internal("GL_EXT_mesh_shader");
break;
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
default:
break;
}
if (!pls_inputs.empty() || !pls_outputs.empty())
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
{
if (execution.model != ExecutionModelFragment)
SPIRV_CROSS_THROW("Can only use GL_EXT_shader_pixel_local_storage in fragment shaders.");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_EXT_shader_pixel_local_storage");
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
}
if (!inout_color_attachments.empty())
{
if (execution.model != ExecutionModelFragment)
SPIRV_CROSS_THROW("Can only use GL_EXT_shader_framebuffer_fetch in fragment shaders.");
if (options.vulkan_semantics)
SPIRV_CROSS_THROW("Cannot use EXT_shader_framebuffer_fetch in Vulkan GLSL.");
GLSL: Implement noncoherent framebuffer fetch.
2021-05-21 12:21:13 +00:00
bool has_coherent = false;
bool has_incoherent = false;
for (auto &att : inout_color_attachments)
{
if (att.second)
has_coherent = true;
else
has_incoherent = true;
}
if (has_coherent)
require_extension_internal("GL_EXT_shader_framebuffer_fetch");
if (has_incoherent)
require_extension_internal("GL_EXT_shader_framebuffer_fetch_non_coherent");
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
}
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
if (options.separate_shader_objects && !options.es && options.version < 410)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_separate_shader_objects");
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT)
{
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("GL_EXT_buffer_reference is only supported in Vulkan GLSL.");
if (options.es && options.version < 320)
SPIRV_CROSS_THROW("GL_EXT_buffer_reference requires ESSL 320.");
else if (!options.es && options.version < 450)
SPIRV_CROSS_THROW("GL_EXT_buffer_reference requires GLSL 450.");
GLSL: Use buffer_reference2 instead of 1. Supports more syntax.
2023-10-11 12:18:36 +00:00
require_extension_internal("GL_EXT_buffer_reference2");
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
}
else if (ir.addressing_model != AddressingModelLogical)
{
SPIRV_CROSS_THROW("Only Logical and PhysicalStorageBuffer64EXT addressing models are supported.");
}
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
// Check for nonuniform qualifier and passthrough.
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
// Instead of looping over all decorations to find this, just look at capabilities.
for (auto &cap : ir.declared_capabilities)
{
switch (cap)
{
case CapabilityShaderNonUniformEXT:
Fix issue #1327 Drop the nonuniform_qualifier in GLSL downcompile NV_gpu_shader5 supports divergent indexing transparently, but obviously runtime sized descriptor arrays are not supported by anything in OpenGL.
2020-04-18 19:21:43 +00:00
if (!options.vulkan_semantics)
require_extension_internal("GL_NV_gpu_shader5");
else
require_extension_internal("GL_EXT_nonuniform_qualifier");
break;
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
case CapabilityRuntimeDescriptorArrayEXT:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("GL_EXT_nonuniform_qualifier is only supported in Vulkan GLSL.");
require_extension_internal("GL_EXT_nonuniform_qualifier");
break;
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
case CapabilityGeometryShaderPassthroughNV:
if (execution.model == ExecutionModelGeometry)
{
require_extension_internal("GL_NV_geometry_shader_passthrough");
execution.geometry_passthrough = true;
}
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
break;
GLSL/HLSL: Disallow VariablePointers capability outright. Cannot be supported, error out early.
2020-12-07 11:16:02 +00:00
case CapabilityVariablePointers:
case CapabilityVariablePointersStorageBuffer:
SPIRV_CROSS_THROW("VariablePointers capability is not supported in GLSL.");
GLSL: Emit num_views for OVR_multiview2.
2021-06-28 10:55:37 +00:00
case CapabilityMultiView:
if (options.vulkan_semantics)
require_extension_internal("GL_EXT_multiview");
else
{
require_extension_internal("GL_OVR_multiview2");
if (options.ovr_multiview_view_count == 0)
SPIRV_CROSS_THROW("ovr_multiview_view_count must be non-zero when using GL_OVR_multiview2.");
if (get_execution_model() != ExecutionModelVertex)
SPIRV_CROSS_THROW("OVR_multiview2 can only be used with Vertex shaders.");
}
break;
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
case CapabilityRayQueryKHR:
if (options.es || options.version < 460 || !options.vulkan_semantics)
SPIRV_CROSS_THROW("RayQuery requires Vulkan GLSL 460.");
require_extension_internal("GL_EXT_ray_query");
ray_tracing_is_khr = true;
break;
case CapabilityRayTraversalPrimitiveCullingKHR:
if (options.es || options.version < 460 || !options.vulkan_semantics)
SPIRV_CROSS_THROW("RayQuery requires Vulkan GLSL 460.");
require_extension_internal("GL_EXT_ray_flags_primitive_culling");
ray_tracing_is_khr = true;
break;
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
default:
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
break;
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
}
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
}
GLSL: Emit num_views for OVR_multiview2.
2021-06-28 10:55:37 +00:00
if (options.ovr_multiview_view_count)
{
if (options.vulkan_semantics)
SPIRV_CROSS_THROW("OVR_multiview2 cannot be used with Vulkan semantics.");
if (get_execution_model() != ExecutionModelVertex)
SPIRV_CROSS_THROW("OVR_multiview2 can only be used with Vertex shaders.");
require_extension_internal("GL_OVR_multiview2");
}
Emit KHR barycentrics if source enables the KHR extension. For roundtrip purposes, need to match KHR or NV extension.
2022-05-27 11:27:48 +00:00
// KHR one is likely to get promoted at some point, so if we don't see an explicit SPIR-V extension, assume KHR.
for (auto &ext : ir.declared_extensions)
if (ext == "SPV_NV_fragment_shader_barycentric")
barycentric_is_nv = true;
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
}
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
void CompilerGLSL::require_polyfill(Polyfill polyfill, bool relaxed)
{
GLSL: Use SPIR-V intrinsics for N{Min,Max,Clamp}. When targeting Vulkan semantics, we should emit code that is actually readable. Also, make sure to use plain F{Min,Max,Clamp} on HLSL. HLSL has NaN-aware semantics by default.
2024-05-21 14:52:51 +00:00
uint32_t &polyfills = (relaxed && (options.es || options.vulkan_semantics)) ?
required_polyfills_relaxed : required_polyfills;
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
if ((polyfills & polyfill) == 0)
{
polyfills |= polyfill;
force_recompile();
}
}
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
void CompilerGLSL::ray_tracing_khr_fixup_locations()
{
uint32_t location = 0;
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
GLSL: Handle tracing against incoming payload/callable.
2021-01-22 10:22:10 +00:00
// Incoming payload storage can also be used for tracing.
if (var.storage != StorageClassRayPayloadKHR && var.storage != StorageClassCallableDataKHR &&
var.storage != StorageClassIncomingRayPayloadKHR && var.storage != StorageClassIncomingCallableDataKHR)
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
return;
Check entry point variables in is_hidden_variables. Need to be careful not to emit globals we're not supposed to.
2021-01-22 12:48:16 +00:00
if (is_hidden_variable(var))
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
return;
set_decoration(var.self, DecorationLocation, location++);
});
}
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::compile()
{
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
ir.fixup_reserved_names();
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
if (!options.vulkan_semantics)
Fix issue #1327 Drop the nonuniform_qualifier in GLSL downcompile NV_gpu_shader5 supports divergent indexing transparently, but obviously runtime sized descriptor arrays are not supported by anything in OpenGL.
2020-04-18 19:21:43 +00:00
{
// only NV_gpu_shader5 supports divergent indexing on OpenGL, and it does so without extra qualifiers
backend.nonuniform_qualifier = "";
GLSL: added an option to disable row-major-load workaround.
2022-08-24 03:07:12 +00:00
backend.needs_row_major_load_workaround = options.enable_row_major_load_workaround;
Fix issue #1327 Drop the nonuniform_qualifier in GLSL downcompile NV_gpu_shader5 supports divergent indexing transparently, but obviously runtime sized descriptor arrays are not supported by anything in OpenGL.
2020-04-18 19:21:43 +00:00
}
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
backend.allow_precision_qualifiers = options.vulkan_semantics || options.es;
Opt in to gl_in/gl_out handling rather than other way around.
2018-01-09 08:16:33 +00:00
backend.force_gl_in_out_block = true;
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
backend.supports_extensions = true;
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
backend.use_array_constructor = true;
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
backend.workgroup_size_is_hidden = true;
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
backend.requires_relaxed_precision_analysis = options.es || options.vulkan_semantics;
backend.support_precise_qualifier =
(!options.es && options.version >= 400) || (options.es && options.version >= 320);
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
GLSL: Implement switch on ESSL 1.0. Cannot use switch on legacy ESSL, fallback to plain branches.
2020-06-29 11:23:13 +00:00
if (is_legacy_es())
backend.support_case_fallthrough = false;
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
// Scan the SPIR-V to find trivial uses of extensions.
Fixup names of anonymous inner structs. Just like we try to fixup struct names for block types, inner structs can be "anonymous" structs. HLSL codegen from DXC tends to emit this, and emitting dummy struct names tends to break GL linkage on some drivers.
2022-03-10 14:38:57 +00:00
fixup_anonymous_struct_names();
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
fixup_type_alias();
reorder_type_alias();
Hoist out variable scope analysis.
2018-07-05 08:42:05 +00:00
build_function_control_flow_graphs_and_analyze();
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
find_static_extensions();
Fix handling of NoWrite/NoRead decoration for images. The old workaround for glslang is no longer needed, so only apply workaround carefully.
2017-01-05 17:16:33 +00:00
fixup_image_load_store_access();
Add traversal for active builtin variables. Refactor some ugly type-copying for access chains.
2017-03-06 14:21:00 +00:00
update_active_builtins();
Implement subpass input support in HLSL.
2018-02-09 09:26:20 +00:00
analyze_image_and_sampler_usage();
Deal with complex interlock cases in GLSL.
2019-09-04 10:18:04 +00:00
analyze_interlocked_resource_usage();
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
if (!inout_color_attachments.empty())
emit_inout_fragment_outputs_copy_to_subpass_inputs();
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
// Shaders might cast unrelated data to pointers of non-block types.
// Find all such instances and make sure we can cast the pointers to a synthesized block type.
if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT)
analyze_non_block_pointer_types();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t pass_count = 0;
do
{
Rework how loop iteration counts are validated. Introduces an idea of a recompilation making forward progress. There are some extreme edge cases where we need more than 3 loops, but only allow this in specific circumstances where we can reason about forward progress being made.
2022-01-17 13:12:01 +00:00
reset(pass_count);
Initial commit.
2016-03-02 17:09:16 +00:00
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
buffer.reset();
Initial commit.
2016-03-02 17:09:16 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_header();
emit_resources();
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
emit_extension_workarounds(get_execution_model());
Initial commit.
2016-03-02 17:09:16 +00:00
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
if (required_polyfills != 0)
emit_polyfills(required_polyfills, false);
GLSL: Use SPIR-V intrinsics for N{Min,Max,Clamp}. When targeting Vulkan semantics, we should emit code that is actually readable. Also, make sure to use plain F{Min,Max,Clamp} on HLSL. HLSL has NaN-aware semantics by default.
2024-05-21 14:52:51 +00:00
if ((options.es || options.vulkan_semantics) && required_polyfills_relaxed != 0)
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
emit_polyfills(required_polyfills_relaxed, true);
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
emit_function(get<SPIRFunction>(ir.default_entry_point), Bitset());
Initial commit.
2016-03-02 17:09:16 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
pass_count++;
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
} while (is_forcing_recompilation());
Initial commit.
2016-03-02 17:09:16 +00:00
Deal with complex interlock cases in GLSL.
2019-09-04 10:18:04 +00:00
// Implement the interlocked wrapper function at the end.
// The body was implemented in lieu of main().
if (interlocked_is_complex)
{
statement("void main()");
begin_scope();
statement("// Interlocks were used in a way not compatible with GLSL, this is very slow.");
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
statement("SPIRV_Cross_beginInvocationInterlock();");
Deal with complex interlock cases in GLSL.
2019-09-04 10:18:04 +00:00
statement("spvMainInterlockedBody();");
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
statement("SPIRV_Cross_endInvocationInterlock();");
Deal with complex interlock cases in GLSL.
2019-09-04 10:18:04 +00:00
end_scope();
}
Add support for renaming entry points.
2017-11-13 12:49:11 +00:00
// Entry point in GLSL is always main().
get_entry_point().name = "main";
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
return buffer.str();
Initial commit.
2016-03-02 17:09:16 +00:00
}
CompilerMSL fix func_call_arg() cast error when not passed SPIRVariable type. CompilerGLSL allow retrieval of partial source if an error occurs.
2016-11-27 17:34:04 +00:00
std::string CompilerGLSL::get_partial_source()
{
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
return buffer.str();
CompilerMSL fix func_call_arg() cast error when not passed SPIRVariable type. CompilerGLSL allow retrieval of partial source if an error occurs.
2016-11-27 17:34:04 +00:00
}
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
void CompilerGLSL::build_workgroup_size(SmallVector<string> &arguments, const SpecializationConstant &wg_x,
Run format_all.sh.
2018-11-01 10:23:33 +00:00
const SpecializationConstant &wg_y, const SpecializationConstant &wg_z)
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
{
auto &execution = get_entry_point();
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
bool builtin_workgroup = execution.workgroup_size.constant != 0;
bool use_local_size_id = !builtin_workgroup && execution.flags.get(ExecutionModeLocalSizeId);
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
if (wg_x.id)
{
if (options.vulkan_semantics)
arguments.push_back(join("local_size_x_id = ", wg_x.constant_id));
else
arguments.push_back(join("local_size_x = ", get<SPIRConstant>(wg_x.id).specialization_constant_macro_name));
}
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
else if (use_local_size_id && execution.workgroup_size.id_x)
arguments.push_back(join("local_size_x = ", get<SPIRConstant>(execution.workgroup_size.id_x).scalar()));
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
else
arguments.push_back(join("local_size_x = ", execution.workgroup_size.x));
if (wg_y.id)
{
if (options.vulkan_semantics)
arguments.push_back(join("local_size_y_id = ", wg_y.constant_id));
else
arguments.push_back(join("local_size_y = ", get<SPIRConstant>(wg_y.id).specialization_constant_macro_name));
}
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
else if (use_local_size_id && execution.workgroup_size.id_y)
arguments.push_back(join("local_size_y = ", get<SPIRConstant>(execution.workgroup_size.id_y).scalar()));
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
else
arguments.push_back(join("local_size_y = ", execution.workgroup_size.y));
if (wg_z.id)
{
if (options.vulkan_semantics)
arguments.push_back(join("local_size_z_id = ", wg_z.constant_id));
else
arguments.push_back(join("local_size_z = ", get<SPIRConstant>(wg_z.id).specialization_constant_macro_name));
}
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
else if (use_local_size_id && execution.workgroup_size.id_z)
arguments.push_back(join("local_size_z = ", get<SPIRConstant>(execution.workgroup_size.id_z).scalar()));
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
else
arguments.push_back(join("local_size_z = ", execution.workgroup_size.z));
}
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
void CompilerGLSL::request_subgroup_feature(ShaderSubgroupSupportHelper::Feature feature)
{
if (options.vulkan_semantics)
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto khr_extension = ShaderSubgroupSupportHelper::get_KHR_extension_for_feature(feature);
require_extension_internal(ShaderSubgroupSupportHelper::get_extension_name(khr_extension));
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
else
{
if (!shader_subgroup_supporter.is_feature_requested(feature))
force_recompile();
shader_subgroup_supporter.request_feature(feature);
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::emit_header()
{
Add support for multiple entry points. - Only consider I/O variables if part of OpEntryPoint. - Keep a safe fallback if #entry-points is 1 to avoid potentially breaking previously working shaders.
2016-07-28 09:16:02 +00:00
auto &execution = get_entry_point();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("#version ", options.version, options.es && options.version > 100 ? " es" : "");
Require GL_ARB_shader_image_load_store extension. The early_fragment_tests layout qualifier requires either OpenGL 4.2 or use of the GL_ARB_shader_image_load_store extension.
2017-10-09 09:33:42 +00:00
if (!options.es && options.version < 420)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Require GL_ARB_shader_image_load_store extension. The early_fragment_tests layout qualifier requires either OpenGL 4.2 or use of the GL_ARB_shader_image_load_store extension.
2017-10-09 09:33:42 +00:00
// Needed for binding = # on UBOs, etc.
if (options.enable_420pack_extension)
{
statement("#ifdef GL_ARB_shading_language_420pack");
statement("#extension GL_ARB_shading_language_420pack : require");
statement("#endif");
}
// Needed for: layout(early_fragment_tests) in;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeEarlyFragmentTests))
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_shader_image_load_store");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Support the SPV_KHR_post_depth_coverage extension. Using the `PostDepthCoverage` mode specifies that the `gl_SampleMaskIn` variable is to contain the computed coverage mask following the early fragment tests, which this mode requires and implicitly enables. Note that unlike Vulkan and OpenGL, Metal places this on the sample mask input itself, and furthermore does *not* implicitly enable early fragment testing. If it isn't enabled explicitly with an `[[early_fragment_tests]]` attribute, the compiler will error out. So we have to enable that mode explicitly if `PostDepthCoverage` is enabled but `EarlyFragmentTests` isn't. For Metal, only iOS supports this; for some reason, Apple has yet to implement it on macOS, even though many desktop cards support it.
2019-07-11 03:42:39 +00:00
// Needed for: layout(post_depth_coverage) in;
if (execution.flags.get(ExecutionModePostDepthCoverage))
require_extension_internal("GL_ARB_post_depth_coverage");
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
// Needed for: layout({pixel,sample}_interlock_[un]ordered) in;
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
bool interlock_used = execution.flags.get(ExecutionModePixelInterlockOrderedEXT) ||
execution.flags.get(ExecutionModePixelInterlockUnorderedEXT) ||
execution.flags.get(ExecutionModeSampleInterlockOrderedEXT) ||
execution.flags.get(ExecutionModeSampleInterlockUnorderedEXT);
if (interlock_used)
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
{
if (options.es)
{
if (options.version < 310)
SPIRV_CROSS_THROW("At least ESSL 3.10 required for fragment shader interlock.");
require_extension_internal("GL_NV_fragment_shader_interlock");
}
else
{
if (options.version < 420)
require_extension_internal("GL_ARB_shader_image_load_store");
require_extension_internal("GL_ARB_fragment_shader_interlock");
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (auto &ext : forced_extensions)
Use GL_NV_gpu_shader5 as a fallback for AMD_gpu_shader_half_float.
2018-08-23 13:37:09 +00:00
{
GLSL: Add more extension ladder fallbacks for unusual integer sizes.
2022-06-07 13:39:37 +00:00
if (ext == "GL_ARB_gpu_shader_int64")
{
statement("#if defined(GL_ARB_gpu_shader_int64)");
statement("#extension GL_ARB_gpu_shader_int64 : require");
if (!options.vulkan_semantics || options.es)
{
statement("#elif defined(GL_NV_gpu_shader5)");
statement("#extension GL_NV_gpu_shader5 : require");
}
statement("#else");
statement("#error No extension available for 64-bit integers.");
statement("#endif");
}
else if (ext == "GL_EXT_shader_explicit_arithmetic_types_float16")
Use GL_NV_gpu_shader5 as a fallback for AMD_gpu_shader_half_float.
2018-08-23 13:37:09 +00:00
{
// Special case, this extension has a potential fallback to another vendor extension in normal GLSL.
// GL_AMD_gpu_shader_half_float is a superset, so try that first.
statement("#if defined(GL_AMD_gpu_shader_half_float)");
statement("#extension GL_AMD_gpu_shader_half_float : require");
Add support for 8- and 16-bit types to GLSL and MSL. In GLSL, 8-bit types require GL_EXT_shader_8bit_storage. 16-bit types can use either GL_AMD_gpu_shader_int16/GL_AMD_gpu_shader_half_float or GL_EXT_shader_16bit_storage.
2018-10-31 14:43:03 +00:00
if (!options.vulkan_semantics)
{
statement("#elif defined(GL_NV_gpu_shader5)");
statement("#extension GL_NV_gpu_shader5 : require");
}
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
else
{
statement("#elif defined(GL_EXT_shader_explicit_arithmetic_types_float16)");
statement("#extension GL_EXT_shader_explicit_arithmetic_types_float16 : require");
}
Use GL_NV_gpu_shader5 as a fallback for AMD_gpu_shader_half_float.
2018-08-23 13:37:09 +00:00
statement("#else");
statement("#error No extension available for FP16.");
statement("#endif");
}
GLSL: Add more extension ladder fallbacks for unusual integer sizes.
2022-06-07 13:39:37 +00:00
else if (ext == "GL_EXT_shader_explicit_arithmetic_types_int8")
{
if (options.vulkan_semantics)
statement("#extension GL_EXT_shader_explicit_arithmetic_types_int8 : require");
else
{
statement("#if defined(GL_EXT_shader_explicit_arithmetic_types_int8)");
statement("#extension GL_EXT_shader_explicit_arithmetic_types_int8 : require");
statement("#elif defined(GL_NV_gpu_shader5)");
statement("#extension GL_NV_gpu_shader5 : require");
statement("#else");
statement("#error No extension available for Int8.");
statement("#endif");
}
}
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
else if (ext == "GL_EXT_shader_explicit_arithmetic_types_int16")
Add support for 8- and 16-bit types to GLSL and MSL. In GLSL, 8-bit types require GL_EXT_shader_8bit_storage. 16-bit types can use either GL_AMD_gpu_shader_int16/GL_AMD_gpu_shader_half_float or GL_EXT_shader_16bit_storage.
2018-10-31 14:43:03 +00:00
{
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
if (options.vulkan_semantics)
statement("#extension GL_EXT_shader_explicit_arithmetic_types_int16 : require");
else
{
GLSL: Add more extension ladder fallbacks for unusual integer sizes.
2022-06-07 13:39:37 +00:00
statement("#if defined(GL_EXT_shader_explicit_arithmetic_types_int16)");
statement("#extension GL_EXT_shader_explicit_arithmetic_types_int16 : require");
statement("#elif defined(GL_AMD_gpu_shader_int16)");
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
statement("#extension GL_AMD_gpu_shader_int16 : require");
Fixed 16 bit int types
2021-05-05 19:41:53 +00:00
statement("#elif defined(GL_NV_gpu_shader5)");
statement("#extension GL_NV_gpu_shader5 : require");
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
statement("#else");
statement("#error No extension available for Int16.");
statement("#endif");
}
Add support for 8- and 16-bit types to GLSL and MSL. In GLSL, 8-bit types require GL_EXT_shader_8bit_storage. 16-bit types can use either GL_AMD_gpu_shader_int16/GL_AMD_gpu_shader_half_float or GL_EXT_shader_16bit_storage.
2018-10-31 14:43:03 +00:00
}
GLSL: Fix post-depth coverage for ESSL. ESSL does not support `GL_ARB_post_depth_coverage`. There, we must use `GL_EXT_post_depth_coverage`. I've added this as a fallback for desktop as well. Note that `GL_EXT_post_depth_coverage` also requires the fragment shader to set `early_fragment_tests` explicitly, while `GL_ARB_post_depth_coverage` does not. It doesn't really matter either way, since `SPV_KHR_post_depth_coverage` *also* requires both execution modes to be explicitly set.
2019-08-03 02:02:05 +00:00
else if (ext == "GL_ARB_post_depth_coverage")
{
if (options.es)
statement("#extension GL_EXT_post_depth_coverage : require");
else
{
statement("#if defined(GL_ARB_post_depth_coverge)");
statement("#extension GL_ARB_post_depth_coverage : require");
statement("#else");
statement("#extension GL_EXT_post_depth_coverage : require");
statement("#endif");
}
}
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
else if (!options.vulkan_semantics && ext == "GL_ARB_shader_draw_parameters")
{
// Soft-enable this extension on plain GLSL.
statement("#ifdef ", ext);
statement("#extension ", ext, " : enable");
statement("#endif");
}
GLSL: Implement control flow hints.
2021-06-03 10:00:29 +00:00
else if (ext == "GL_EXT_control_flow_attributes")
{
// These are just hints so we can conditionally enable and fallback in the shader.
statement("#if defined(GL_EXT_control_flow_attributes)");
statement("#extension GL_EXT_control_flow_attributes : require");
statement("#define SPIRV_CROSS_FLATTEN [[flatten]]");
statement("#define SPIRV_CROSS_BRANCH [[dont_flatten]]");
statement("#define SPIRV_CROSS_UNROLL [[unroll]]");
statement("#define SPIRV_CROSS_LOOP [[dont_unroll]]");
statement("#else");
statement("#define SPIRV_CROSS_FLATTEN");
statement("#define SPIRV_CROSS_BRANCH");
statement("#define SPIRV_CROSS_UNROLL");
statement("#define SPIRV_CROSS_LOOP");
statement("#endif");
}
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
else if (ext == "GL_NV_fragment_shader_interlock")
{
statement("#extension GL_NV_fragment_shader_interlock : require");
statement("#define SPIRV_Cross_beginInvocationInterlock() beginInvocationInterlockNV()");
statement("#define SPIRV_Cross_endInvocationInterlock() endInvocationInterlockNV()");
}
else if (ext == "GL_ARB_fragment_shader_interlock")
{
statement("#ifdef GL_ARB_fragment_shader_interlock");
statement("#extension GL_ARB_fragment_shader_interlock : enable");
statement("#define SPIRV_Cross_beginInvocationInterlock() beginInvocationInterlockARB()");
statement("#define SPIRV_Cross_endInvocationInterlock() endInvocationInterlockARB()");
statement("#elif defined(GL_INTEL_fragment_shader_ordering)");
statement("#extension GL_INTEL_fragment_shader_ordering : enable");
statement("#define SPIRV_Cross_beginInvocationInterlock() beginFragmentShaderOrderingINTEL()");
statement("#define SPIRV_Cross_endInvocationInterlock()");
statement("#endif");
}
Use GL_NV_gpu_shader5 as a fallback for AMD_gpu_shader_half_float.
2018-08-23 13:37:09 +00:00
else
statement("#extension ", ext, " : require");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (!options.vulkan_semantics)
{
using Supp = ShaderSubgroupSupportHelper;
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto result = shader_subgroup_supporter.resolve();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (uint32_t feature_index = 0; feature_index < Supp::FeatureCount; feature_index++)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto feature = static_cast<Supp::Feature>(feature_index);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (!shader_subgroup_supporter.is_feature_requested(feature))
continue;
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto exts = Supp::get_candidates_for_feature(feature, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (exts.empty())
continue;
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &ext : exts)
{
const char *name = Supp::get_extension_name(ext);
const char *extra_predicate = Supp::get_extra_required_extension_predicate(ext);
auto extra_names = Supp::get_extra_required_extension_names(ext);
statement(&ext != &exts.front() ? "#elif" : "#if", " defined(", name, ")",
(*extra_predicate != '\0' ? " && " : ""), extra_predicate);
for (const auto &e : extra_names)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("#extension ", e, " : enable");
statement("#extension ", name, " : require");
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
if (!Supp::can_feature_be_implemented_without_extensions(feature))
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
statement("#else");
statement("#error No extensions available to emulate requested subgroup feature.");
}
statement("#endif");
}
}
Move static extension checking out to appropriate method. Also make sure extra statements are placed after extensions as extra statements can depend on extensions.
2016-09-23 12:21:30 +00:00
for (auto &header : header_lines)
statement(header);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<string> inputs;
SmallVector<string> outputs;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (execution.model)
{
GLSL: Emit num_views for OVR_multiview2.
2021-06-28 10:55:37 +00:00
case ExecutionModelVertex:
if (options.ovr_multiview_view_count)
inputs.push_back(join("num_views = ", options.ovr_multiview_view_count));
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case ExecutionModelGeometry:
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if ((execution.flags.get(ExecutionModeInvocations)) && execution.invocations != 1)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back(join("invocations = ", execution.invocations));
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeInputPoints))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("points");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeInputLines))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("lines");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeInputLinesAdjacency))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("lines_adjacency");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeTriangles))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("triangles");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeInputTrianglesAdjacency))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("triangles_adjacency");
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
if (!execution.geometry_passthrough)
{
// For passthrough, these are implies and cannot be declared in shader.
outputs.push_back(join("max_vertices = ", execution.output_vertices));
if (execution.flags.get(ExecutionModeOutputTriangleStrip))
outputs.push_back("triangle_strip");
if (execution.flags.get(ExecutionModeOutputPoints))
outputs.push_back("points");
if (execution.flags.get(ExecutionModeOutputLineStrip))
outputs.push_back("line_strip");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case ExecutionModelTessellationControl:
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeOutputVertices))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
outputs.push_back(join("vertices = ", execution.output_vertices));
break;
case ExecutionModelTessellationEvaluation:
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeQuads))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("quads");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeTriangles))
Fix triangle mode in tessellation output.
2016-09-28 06:12:04 +00:00
inputs.push_back("triangles");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeIsolines))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("isolines");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModePointMode))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("point_mode");
Fix triangle mode in tessellation output.
2016-09-28 06:12:04 +00:00
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (!execution.flags.get(ExecutionModeIsolines))
Fix triangle mode in tessellation output.
2016-09-28 06:12:04 +00:00
{
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeVertexOrderCw))
Fix triangle mode in tessellation output.
2016-09-28 06:12:04 +00:00
inputs.push_back("cw");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeVertexOrderCcw))
Fix triangle mode in tessellation output.
2016-09-28 06:12:04 +00:00
inputs.push_back("ccw");
}
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeSpacingFractionalEven))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("fractional_even_spacing");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeSpacingFractionalOdd))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("fractional_odd_spacing");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeSpacingEqual))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("equal_spacing");
break;
case ExecutionModelGLCompute:
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
case ExecutionModelTaskEXT:
case ExecutionModelMeshEXT:
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
{
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
if (execution.workgroup_size.constant != 0 || execution.flags.get(ExecutionModeLocalSizeId))
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
{
SpecializationConstant wg_x, wg_y, wg_z;
get_work_group_size_specialization_constants(wg_x, wg_y, wg_z);
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
// If there are any spec constants on legacy GLSL, defer declaration, we need to set up macro
// declarations before we can emit the work group size.
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
if (options.vulkan_semantics ||
((wg_x.id == ConstantID(0)) && (wg_y.id == ConstantID(0)) && (wg_z.id == ConstantID(0))))
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
build_workgroup_size(inputs, wg_x, wg_y, wg_z);
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
}
else
{
inputs.push_back(join("local_size_x = ", execution.workgroup_size.x));
inputs.push_back(join("local_size_y = ", execution.workgroup_size.y));
inputs.push_back(join("local_size_z = ", execution.workgroup_size.z));
}
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if (execution.model == ExecutionModelMeshEXT)
{
outputs.push_back(join("max_vertices = ", execution.output_vertices));
outputs.push_back(join("max_primitives = ", execution.output_primitives));
if (execution.flags.get(ExecutionModeOutputTrianglesEXT))
outputs.push_back("triangles");
else if (execution.flags.get(ExecutionModeOutputLinesEXT))
outputs.push_back("lines");
else if (execution.flags.get(ExecutionModeOutputPoints))
outputs.push_back("points");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case ExecutionModelFragment:
if (options.es)
{
switch (options.fragment.default_float_precision)
{
case Options::Lowp:
statement("precision lowp float;");
break;
case Options::Mediump:
statement("precision mediump float;");
break;
case Options::Highp:
statement("precision highp float;");
break;
default:
break;
}
switch (options.fragment.default_int_precision)
{
case Options::Lowp:
statement("precision lowp int;");
break;
case Options::Mediump:
statement("precision mediump int;");
break;
case Options::Highp:
statement("precision highp int;");
break;
default:
break;
}
}
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeEarlyFragmentTests))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
inputs.push_back("early_fragment_tests");
Support the SPV_KHR_post_depth_coverage extension. Using the `PostDepthCoverage` mode specifies that the `gl_SampleMaskIn` variable is to contain the computed coverage mask following the early fragment tests, which this mode requires and implicitly enables. Note that unlike Vulkan and OpenGL, Metal places this on the sample mask input itself, and furthermore does *not* implicitly enable early fragment testing. If it isn't enabled explicitly with an `[[early_fragment_tests]]` attribute, the compiler will error out. So we have to enable that mode explicitly if `PostDepthCoverage` is enabled but `EarlyFragmentTests` isn't. For Metal, only iOS supports this; for some reason, Apple has yet to implement it on macOS, even though many desktop cards support it.
2019-07-11 03:42:39 +00:00
if (execution.flags.get(ExecutionModePostDepthCoverage))
inputs.push_back("post_depth_coverage");
Deal with depth_greater/depth_less qualifiers. Adds support on HLSL SM 5.0, and fixes bug on GLSL. Makes sure early fragment tests is tested on MSL as well.
2018-11-12 09:29:59 +00:00
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
if (interlock_used)
statement("#if defined(GL_ARB_fragment_shader_interlock)");
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
if (execution.flags.get(ExecutionModePixelInterlockOrderedEXT))
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
statement("layout(pixel_interlock_ordered) in;");
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
else if (execution.flags.get(ExecutionModePixelInterlockUnorderedEXT))
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
statement("layout(pixel_interlock_unordered) in;");
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
else if (execution.flags.get(ExecutionModeSampleInterlockOrderedEXT))
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
statement("layout(sample_interlock_ordered) in;");
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
else if (execution.flags.get(ExecutionModeSampleInterlockUnorderedEXT))
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
statement("layout(sample_interlock_unordered) in;");
if (interlock_used)
{
statement("#elif !defined(GL_INTEL_fragment_shader_ordering)");
statement("#error Fragment Shader Interlock/Ordering extension missing!");
statement("#endif");
}
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
Deal with depth_greater/depth_less qualifiers. Adds support on HLSL SM 5.0, and fixes bug on GLSL. Makes sure early fragment tests is tested on MSL as well.
2018-11-12 09:29:59 +00:00
if (!options.es && execution.flags.get(ExecutionModeDepthGreater))
statement("layout(depth_greater) out float gl_FragDepth;");
else if (!options.es && execution.flags.get(ExecutionModeDepthLess))
statement("layout(depth_less) out float gl_FragDepth;");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
default:
break;
}
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
for (auto &cap : ir.declared_capabilities)
if (cap == CapabilityRayTraversalPrimitiveCullingKHR)
statement("layout(primitive_culling);");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!inputs.empty())
statement("layout(", merge(inputs), ") in;");
if (!outputs.empty())
statement("layout(", merge(outputs), ") out;");
statement("");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Workaround empty struct declaration and empty IO variables.
2017-03-24 09:03:11 +00:00
bool CompilerGLSL::type_is_empty(const SPIRType &type)
{
return type.basetype == SPIRType::Struct && type.member_types.empty();
}
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
void CompilerGLSL::emit_struct(SPIRType &type)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Struct types can be stamped out multiple times
// with just different offsets, matrix layouts, etc ...
// Type-punning with these types is legal, which complicates things
// when we are storing struct and array types in an SSBO for example.
Fix type aliasing on MSL. Be careful about who gets to be the alias master, and don't alias types when we have packed types in play.
2018-03-05 15:27:04 +00:00
// If the type master is packed however, we can no longer assume that the struct declaration will be redundant.
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
if (type.type_alias != TypeID(0) &&
!has_extended_decoration(type.type_alias, SPIRVCrossDecorationBufferBlockRepacked))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return;
Do not rely on OpName when finding OpTypeStruct aliases. SPIR-V can stamp out multiple variants of the same types to deal with different offsets, layouts, array strides and so on in buffer blocks.
2016-05-23 08:57:22 +00:00
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
add_resource_name(type.self);
Do not rely on OpName when finding OpTypeStruct aliases. SPIR-V can stamp out multiple variants of the same types to deal with different offsets, layouts, array strides and so on in buffer blocks.
2016-05-23 08:57:22 +00:00
auto name = type_to_glsl(type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
statement(!backend.explicit_struct_type ? "struct " : "", name);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
begin_scope();
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
type.member_name_cache.clear();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t i = 0;
bool emitted = false;
for (auto &member : type.member_types)
{
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
add_member_name(type, i);
Updates to MSL functionality to support PR review feedback.
2017-03-11 17:17:22 +00:00
emit_struct_member(type, member, i);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
i++;
emitted = true;
}
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
// Don't declare empty structs in GLSL, this is not allowed.
if (type_is_empty(type) && !backend.supports_empty_struct)
{
statement("int empty_struct_member;");
emitted = true;
}
Tests run clean.
2019-07-22 08:23:39 +00:00
if (has_extended_decoration(type.self, SPIRVCrossDecorationPaddingTarget))
emit_struct_padding_target(type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
end_scope_decl();
if (emitted)
statement("");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
string CompilerGLSL::to_interpolation_qualifiers(const Bitset &flags)
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
{
string res;
//if (flags & (1ull << DecorationSmooth))
// res += "smooth ";
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationFlat))
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += "flat ";
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationNoPerspective))
GLSL: Support GL_NV_shader_noperspective_interpolation in GLES
2023-01-16 19:02:13 +00:00
{
if (options.es)
{
if (options.version < 300)
SPIRV_CROSS_THROW("noperspective requires ESSL 300.");
require_extension_internal("GL_NV_shader_noperspective_interpolation");
}
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
else if (is_legacy_desktop())
require_extension_internal("GL_EXT_gpu_shader4");
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += "noperspective ";
GLSL: Support GL_NV_shader_noperspective_interpolation in GLES
2023-01-16 19:02:13 +00:00
}
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationCentroid))
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += "centroid ";
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationPatch))
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += "patch ";
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationSample))
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
{
if (options.es)
{
if (options.version < 300)
SPIRV_CROSS_THROW("sample requires ESSL 300.");
else if (options.version < 320)
require_extension_internal("GL_OES_shader_multisample_interpolation");
}
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += "sample ";
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
}
GLSL: Drop invariant keyword in GLSL 110
2023-01-27 10:10:47 +00:00
if (flags.get(DecorationInvariant) && (options.es || options.version >= 120))
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += "invariant ";
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if (flags.get(DecorationPerPrimitiveEXT))
GLSL: Require mesh shader when using perprimitiveEXT in frag shader.
2023-08-17 10:07:11 +00:00
{
res += "perprimitiveEXT ";
require_extension_internal("GL_EXT_mesh_shader");
}
GLSL: Support pervertexNV in NV barycentric extension.
2021-06-30 13:58:13 +00:00
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationExplicitInterpAMD))
GLSL: Support pervertexNV in NV barycentric extension.
2021-06-30 13:58:13 +00:00
{
require_extension_internal("GL_AMD_shader_explicit_vertex_parameter");
Update tests for latest SPIRV-Tools and glslang.
2018-03-12 13:58:40 +00:00
res += "__explicitInterpAMD ";
GLSL: Support pervertexNV in NV barycentric extension.
2021-06-30 13:58:13 +00:00
}
Emit KHR barycentrics if source enables the KHR extension. For roundtrip purposes, need to match KHR or NV extension.
2022-05-27 11:27:48 +00:00
if (flags.get(DecorationPerVertexKHR))
GLSL: Support pervertexNV in NV barycentric extension.
2021-06-30 13:58:13 +00:00
{
if (options.es && options.version < 320)
Emit KHR barycentrics if source enables the KHR extension. For roundtrip purposes, need to match KHR or NV extension.
2022-05-27 11:27:48 +00:00
SPIRV_CROSS_THROW("pervertexEXT requires ESSL 320.");
GLSL: Support pervertexNV in NV barycentric extension.
2021-06-30 13:58:13 +00:00
else if (!options.es && options.version < 450)
Emit KHR barycentrics if source enables the KHR extension. For roundtrip purposes, need to match KHR or NV extension.
2022-05-27 11:27:48 +00:00
SPIRV_CROSS_THROW("pervertexEXT requires GLSL 450.");
if (barycentric_is_nv)
{
require_extension_internal("GL_NV_fragment_shader_barycentric");
res += "pervertexNV ";
}
else
{
require_extension_internal("GL_EXT_fragment_shader_barycentric");
res += "pervertexEXT ";
}
GLSL: Support pervertexNV in NV barycentric extension.
2021-06-30 13:58:13 +00:00
}
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
return res;
}
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::layout_for_member(const SPIRType &type, uint32_t index)
{
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
if (is_legacy())
return "";
HLSL: Rewrite how block IO is emitted. Emit block members directly in the IO structs and sort them. Ensures we can get some kind of stable order between stages. To complete the story, we'll need to be able to inject unused inputs / builtins, or eliminate unused outputs (probably easiest solution).
2021-06-28 12:24:29 +00:00
bool is_block = has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!is_block)
return "";
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &memb = ir.meta[type.self].members;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (index >= memb.size())
Fix mistaken nullptr returned instead of empty string.
2016-08-13 08:31:01 +00:00
return "";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &dec = memb[index];
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<string> attr;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
if (has_member_decoration(type.self, index, DecorationPassthroughNV))
attr.push_back("passthrough");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// We can only apply layouts on members in block interfaces.
// This is a bit problematic because in SPIR-V decorations are applied on the struct types directly.
// This is not supported on GLSL, so we have to make the assumption that if a struct within our buffer block struct
// has a decoration, it was originally caused by a top-level layout() qualifier in GLSL.
//
// We would like to go from (SPIR-V style):
//
// struct Foo { layout(row_major) mat4 matrix; };
// buffer UBO { Foo foo; };
//
// to
//
// struct Foo { mat4 matrix; }; // GLSL doesn't support any layout shenanigans in raw struct declarations.
// buffer UBO { layout(row_major) Foo foo; }; // Apply the layout on top-level.
auto flags = combined_decoration_for_member(type, index);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationRowMajor))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
attr.push_back("row_major");
// We don't emit any global layouts, so column_major is default.
//if (flags & (1ull << DecorationColMajor))
// attr.push_back("column_major");
Distinguish between enhanced_layouts and SSO requirements. Block locations are 440, but non-block are 410 ...
2018-04-17 12:16:27 +00:00
if (dec.decoration_flags.get(DecorationLocation) && can_use_io_location(type.storage, true))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
attr.push_back(join("location = ", dec.location));
Support Component decoration in GLSL.
2018-09-10 10:13:26 +00:00
// Can only declare component if we can declare location.
if (dec.decoration_flags.get(DecorationComponent) && can_use_io_location(type.storage, true))
{
if (!options.es)
{
if (options.version < 440 && options.version >= 140)
require_extension_internal("GL_ARB_enhanced_layouts");
else if (options.version < 140)
SPIRV_CROSS_THROW("Component decoration is not supported in targets below GLSL 1.40.");
attr.push_back(join("component = ", dec.component));
}
else
SPIRV_CROSS_THROW("Component decoration is not supported in ES targets.");
}
Refactor out packed expressions to extended decorations. Can't safely just cast to the original enum without lots of hacks.
2019-01-17 10:22:24 +00:00
// SPIRVCrossDecorationPacked is set by layout_for_variable earlier to mark that we need to emit offset qualifiers.
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
// This is only done selectively in GLSL as needed.
Run format_all.sh.
2019-07-23 10:23:41 +00:00
if (has_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset) &&
dec.decoration_flags.get(DecorationOffset))
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
attr.push_back(join("offset = ", dec.offset));
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
else if (type.storage == StorageClassOutput && dec.decoration_flags.get(DecorationOffset))
attr.push_back(join("xfb_offset = ", dec.offset));
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (attr.empty())
return "";
string res = "layout(";
res += merge(attr);
res += ") ";
return res;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
const char *CompilerGLSL::format_to_glsl(spv::ImageFormat format)
Initial commit.
2016-03-02 17:09:16 +00:00
{
More feedback
2018-06-20 17:25:38 +00:00
if (options.es && is_desktop_only_format(format))
SPIRV_CROSS_THROW("Attempting to use image format not supported in ES profile.");
Handle all desktop image formats.
2016-07-12 07:35:15 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (format)
{
case ImageFormatRgba32f:
return "rgba32f";
case ImageFormatRgba16f:
return "rgba16f";
case ImageFormatR32f:
return "r32f";
case ImageFormatRgba8:
return "rgba8";
case ImageFormatRgba8Snorm:
return "rgba8_snorm";
case ImageFormatRg32f:
return "rg32f";
case ImageFormatRg16f:
return "rg16f";
case ImageFormatRgba32i:
return "rgba32i";
case ImageFormatRgba16i:
return "rgba16i";
case ImageFormatR32i:
return "r32i";
case ImageFormatRgba8i:
return "rgba8i";
case ImageFormatRg32i:
return "rg32i";
case ImageFormatRg16i:
return "rg16i";
case ImageFormatRgba32ui:
return "rgba32ui";
case ImageFormatRgba16ui:
return "rgba16ui";
case ImageFormatR32ui:
return "r32ui";
case ImageFormatRgba8ui:
return "rgba8ui";
case ImageFormatRg32ui:
return "rg32ui";
case ImageFormatRg16ui:
return "rg16ui";
Handle all desktop image formats.
2016-07-12 07:35:15 +00:00
case ImageFormatR11fG11fB10f:
return "r11f_g11f_b10f";
case ImageFormatR16f:
return "r16f";
case ImageFormatRgb10A2:
return "rgb10_a2";
case ImageFormatR8:
return "r8";
case ImageFormatRg8:
return "rg8";
case ImageFormatR16:
return "r16";
case ImageFormatRg16:
return "rg16";
case ImageFormatRgba16:
return "rgba16";
case ImageFormatR16Snorm:
return "r16_snorm";
case ImageFormatRg16Snorm:
return "rg16_snorm";
case ImageFormatRgba16Snorm:
return "rgba16_snorm";
case ImageFormatR8Snorm:
return "r8_snorm";
case ImageFormatRg8Snorm:
return "rg8_snorm";
case ImageFormatR8ui:
return "r8ui";
case ImageFormatRg8ui:
return "rg8ui";
case ImageFormatR16ui:
return "r16ui";
case ImageFormatRgb10a2ui:
return "rgb10_a2ui";
case ImageFormatR8i:
return "r8i";
case ImageFormatRg8i:
return "rg8i";
case ImageFormatR16i:
return "r16i";
GLSL: Implement 64-bit image support.
2023-08-17 10:17:37 +00:00
case ImageFormatR64i:
return "r64i";
case ImageFormatR64ui:
return "r64ui";
Handle all desktop image formats.
2016-07-12 07:35:15 +00:00
default:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case ImageFormatUnknown:
return nullptr;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
uint32_t CompilerGLSL::type_to_packed_base_size(const SPIRType &type, BufferPackingStandard)
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
{
switch (type.basetype)
{
case SPIRType::Double:
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
case SPIRType::Int64:
case SPIRType::UInt64:
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
return 8;
Fix packing alignments for float16.
2018-03-06 14:39:12 +00:00
case SPIRType::Float:
case SPIRType::Int:
case SPIRType::UInt:
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
return 4;
Fix packing alignments for float16.
2018-03-06 14:39:12 +00:00
case SPIRType::Half:
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
case SPIRType::Short:
case SPIRType::UShort:
Fix packing alignments for float16.
2018-03-06 14:39:12 +00:00
return 2;
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
case SPIRType::SByte:
case SPIRType::UByte:
return 1;
Fix packing alignments for float16.
2018-03-06 14:39:12 +00:00
default:
SPIRV_CROSS_THROW("Unrecognized type in type_to_packed_base_size.");
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
}
}
Run format_all.sh.
2018-03-13 13:05:33 +00:00
uint32_t CompilerGLSL::type_to_packed_alignment(const SPIRType &type, const Bitset &flags,
BufferPackingStandard packing)
Initial commit.
2016-03-02 17:09:16 +00:00
{
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
// If using PhysicalStorageBufferEXT storage class, this is a pointer,
// and is 64-bit.
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
if (is_physical_pointer(type))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
if (!type.pointer)
SPIRV_CROSS_THROW("Types in PhysicalStorageBufferEXT must be pointers.");
if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT)
{
if (packing_is_vec4_padded(packing) && type_is_array_of_pointers(type))
return 16;
else
return 8;
}
else
SPIRV_CROSS_THROW("AddressingModelPhysicalStorageBuffer64EXT must be used for PhysicalStorageBufferEXT.");
}
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
else if (is_array(type))
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
{
uint32_t minimum_alignment = 1;
if (packing_is_vec4_padded(packing))
minimum_alignment = 16;
auto *tmp = &get<SPIRType>(type.parent_type);
while (!tmp->array.empty())
tmp = &get<SPIRType>(tmp->parent_type);
// Get the alignment of the base type, then maybe round up.
return max(minimum_alignment, type_to_packed_alignment(*tmp, flags, packing));
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (type.basetype == SPIRType::Struct)
{
// Rule 9. Structs alignments are maximum alignment of its members.
MSL: Use correct alignment rule for whole structs. Structs are aligned as you would expect in MSL (maximum member alignment), and it is not minimum 16 bytes like in std140. Also rename the dummy "pad" members to a reserved naming scheme.
2019-01-28 10:02:28 +00:00
uint32_t alignment = 1;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (uint32_t i = 0; i < type.member_types.size(); i++)
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto member_flags = ir.meta[type.self].members[i].decoration_flags;
Run format_all.sh.
2017-10-10 08:22:40 +00:00
alignment =
max(alignment, type_to_packed_alignment(get<SPIRType>(type.member_types[i]), member_flags, packing));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
// In std140, struct alignment is rounded up to 16.
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
if (packing_is_vec4_padded(packing))
(spirv_glsl.cpp) Fix error: no matching function for call to 'max(uint32_t&, unsigned int)'
2023-01-20 17:36:11 +00:00
alignment = max<uint32_t>(alignment, 16u);
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return alignment;
}
else
{
Fix packing alignments for float16.
2018-03-06 14:39:12 +00:00
const uint32_t base_alignment = type_to_packed_base_size(type, packing);
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
// Alignment requirement for scalar block layout is always the alignment for the most basic component.
if (packing_is_scalar(packing))
return base_alignment;
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
// Vectors are *not* aligned in HLSL, but there's an extra rule where vectors cannot straddle
// a vec4, this is handled outside since that part knows our current offset.
if (type.columns == 1 && packing_is_hlsl(packing))
return base_alignment;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// From 7.6.2.2 in GL 4.5 core spec.
// Rule 1
if (type.vecsize == 1 && type.columns == 1)
return base_alignment;
// Rule 2
if ((type.vecsize == 2 || type.vecsize == 4) && type.columns == 1)
return type.vecsize * base_alignment;
// Rule 3
if (type.vecsize == 3 && type.columns == 1)
return 4 * base_alignment;
// Rule 4 implied. Alignment does not change in std430.
// Rule 5. Column-major matrices are stored as arrays of
// vectors.
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationColMajor) && type.columns > 1)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
if (packing_is_vec4_padded(packing))
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
return 4 * base_alignment;
else if (type.vecsize == 3)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return 4 * base_alignment;
else
return type.vecsize * base_alignment;
}
// Rule 6 implied.
// Rule 7.
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationRowMajor) && type.vecsize > 1)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
if (packing_is_vec4_padded(packing))
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
return 4 * base_alignment;
else if (type.columns == 3)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return 4 * base_alignment;
else
return type.columns * base_alignment;
}
// Rule 8 implied.
}
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
SPIRV_CROSS_THROW("Did not find suitable rule for type. Bogus decorations?");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Run format_all.sh.
2018-03-13 13:05:33 +00:00
uint32_t CompilerGLSL::type_to_packed_array_stride(const SPIRType &type, const Bitset &flags,
BufferPackingStandard packing)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Array stride is equal to aligned size of the underlying type.
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
uint32_t parent = type.parent_type;
assert(parent);
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
auto &tmp = get<SPIRType>(parent);
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
uint32_t size = type_to_packed_size(tmp, flags, packing);
HLSL: Deal with partially filled 16-byte word in cbuffers. The last element of an array or matrix in HLSL cbuffers are not filled completely, but only have a size equal to the base vector.
2020-08-20 14:05:21 +00:00
uint32_t alignment = type_to_packed_alignment(type, flags, packing);
return (size + alignment - 1) & ~(alignment - 1);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
uint32_t CompilerGLSL::type_to_packed_size(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing)
Initial commit.
2016-03-02 17:09:16 +00:00
{
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
// If using PhysicalStorageBufferEXT storage class, this is a pointer,
// and is 64-bit.
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
if (is_physical_pointer(type))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
if (!type.pointer)
SPIRV_CROSS_THROW("Types in PhysicalStorageBufferEXT must be pointers.");
if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT)
return 8;
else
SPIRV_CROSS_THROW("AddressingModelPhysicalStorageBuffer64EXT must be used for PhysicalStorageBufferEXT.");
}
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
else if (is_array(type))
GLSL: Disambiguate pointer vs array properly in packed_size/alignment.
2023-05-10 10:35:47 +00:00
{
uint32_t packed_size = to_array_size_literal(type) * type_to_packed_array_stride(type, flags, packing);
// For arrays of vectors and matrices in HLSL, the last element has a size which depends on its vector size,
// so that it is possible to pack other vectors into the last element.
if (packing_is_hlsl(packing) && type.basetype != SPIRType::Struct)
packed_size -= (4 - type.vecsize) * (type.width / 8);
return packed_size;
}
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t size = 0;
if (type.basetype == SPIRType::Struct)
{
Handle padding for struct members in buffers. Fixes earlier issues with struct-packing test.
2016-05-05 14:32:15 +00:00
uint32_t pad_alignment = 1;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (uint32_t i = 0; i < type.member_types.size(); i++)
{
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
auto member_flags = ir.meta[type.self].members[i].decoration_flags;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &member_type = get<SPIRType>(type.member_types[i]);
Handle padding for struct members in buffers. Fixes earlier issues with struct-packing test.
2016-05-05 14:32:15 +00:00
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
uint32_t packed_alignment = type_to_packed_alignment(member_type, member_flags, packing);
uint32_t alignment = max(packed_alignment, pad_alignment);
Handle padding for struct members in buffers. Fixes earlier issues with struct-packing test.
2016-05-05 14:32:15 +00:00
// The next member following a struct member is aligned to the base alignment of the struct that came before.
// GL 4.5 spec, 7.6.2.2.
if (member_type.basetype == SPIRType::Struct)
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
pad_alignment = packed_alignment;
Handle padding for struct members in buffers. Fixes earlier issues with struct-packing test.
2016-05-05 14:32:15 +00:00
else
pad_alignment = 1;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
size = (size + alignment - 1) & ~(alignment - 1);
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
size += type_to_packed_size(member_type, member_flags, packing);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
else
{
Fix packing alignments for float16.
2018-03-06 14:39:12 +00:00
const uint32_t base_alignment = type_to_packed_base_size(type, packing);
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
if (packing_is_scalar(packing))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
size = type.vecsize * type.columns * base_alignment;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
else
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
if (type.columns == 1)
size = type.vecsize * base_alignment;
if (flags.get(DecorationColMajor) && type.columns > 1)
{
if (packing_is_vec4_padded(packing))
size = type.columns * 4 * base_alignment;
else if (type.vecsize == 3)
size = type.columns * 4 * base_alignment;
else
size = type.columns * type.vecsize * base_alignment;
}
if (flags.get(DecorationRowMajor) && type.vecsize > 1)
{
if (packing_is_vec4_padded(packing))
size = type.vecsize * 4 * base_alignment;
else if (type.columns == 3)
size = type.vecsize * 4 * base_alignment;
else
size = type.vecsize * type.columns * base_alignment;
}
HLSL: Deal with partially filled 16-byte word in cbuffers. The last element of an array or matrix in HLSL cbuffers are not filled completely, but only have a size equal to the base vector.
2020-08-20 14:05:21 +00:00
// For matrices in HLSL, the last element has a size which depends on its vector size,
// so that it is possible to pack other vectors into the last element.
if (packing_is_hlsl(packing) && type.columns > 1)
size -= (4 - type.vecsize) * (type.width / 8);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
return size;
Initial commit.
2016-03-02 17:09:16 +00:00
}
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
bool CompilerGLSL::buffer_is_packing_standard(const SPIRType &type, BufferPackingStandard packing,
HLSL: Report more explicitly which member failed validation. This will be awkward to report in GLSL where we check multiple packing standards, but for HLSL it should be easy since there's only CBuffer packing standard to worry about.
2019-11-06 10:20:57 +00:00
uint32_t *failed_validation_index, uint32_t start_offset,
uint32_t end_offset)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// This is very tricky and error prone, but try to be exhaustive and correct here.
// SPIR-V doesn't directly say if we're using std430 or std140.
// SPIR-V communicates this using Offset and ArrayStride decorations (which is what really matters),
// so we have to try to infer whether or not the original GLSL source was std140 or std430 based on this information.
// We do not have to consider shared or packed since these layouts are not allowed in Vulkan SPIR-V (they are useless anyways, and custom offsets would do the same thing).
//
// It is almost certain that we're using std430, but it gets tricky with arrays in particular.
// We will assume std430, but infer std140 if we can prove the struct is not compliant with std430.
//
// The only two differences between std140 and std430 are related to padding alignment/array stride
// in arrays and structs. In std140 they take minimum vec4 alignment.
// std430 only removes the vec4 requirement.
uint32_t offset = 0;
Handle padding for struct members in buffers. Fixes earlier issues with struct-packing test.
2016-05-05 14:32:15 +00:00
uint32_t pad_alignment = 1;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Deal with OpSpecConstantOp used as array size. When trying to validate buffer sizes, we usually need to bail out when using SpecConstantOps, but for some very specific cases where we allow unsized arrays currently, we can safely allow "unknown" sized arrays as well. This is probably the best we can do, when we have even more difficult cases than this, we throw a more sensible error message.
2018-11-01 13:56:25 +00:00
bool is_top_level_block =
has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (uint32_t i = 0; i < type.member_types.size(); i++)
{
auto &memb_type = get<SPIRType>(type.member_types[i]);
GLSL: Handle ptr-to-array casts with unexpected array strides.
2024-01-18 13:14:10 +00:00
auto *type_meta = ir.find_meta(type.self);
auto member_flags = type_meta ? type_meta->members[i].decoration_flags : Bitset{};
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Verify alignment rules.
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
uint32_t packed_alignment = type_to_packed_alignment(memb_type, member_flags, packing);
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
Deal with OpSpecConstantOp used as array size. When trying to validate buffer sizes, we usually need to bail out when using SpecConstantOps, but for some very specific cases where we allow unsized arrays currently, we can safely allow "unknown" sized arrays as well. This is probably the best we can do, when we have even more difficult cases than this, we throw a more sensible error message.
2018-11-01 13:56:25 +00:00
// This is a rather dirty workaround to deal with some cases of OpSpecConstantOp used as array size, e.g:
// layout(constant_id = 0) const int s = 10;
// const int S = s + 5; // SpecConstantOp
// buffer Foo { int data[S]; }; // <-- Very hard for us to deduce a fixed value here,
// we would need full implementation of compile-time constant folding. :(
// If we are the last member of a struct, there might be cases where the actual size of that member is irrelevant
// for our analysis (e.g. unsized arrays).
// This lets us simply ignore that there are spec constant op sized arrays in our buffers.
// Querying size of this member will fail, so just don't call it unless we have to.
//
// This is likely "best effort" we can support without going into unacceptably complicated workarounds.
bool member_can_be_unsized =
is_top_level_block && size_t(i + 1) == type.member_types.size() && !memb_type.array.empty();
uint32_t packed_size = 0;
HLSL: Deal with partially filled 16-byte word in cbuffers. The last element of an array or matrix in HLSL cbuffers are not filled completely, but only have a size equal to the base vector.
2020-08-20 14:05:21 +00:00
if (!member_can_be_unsized || packing_is_hlsl(packing))
Deal with OpSpecConstantOp used as array size. When trying to validate buffer sizes, we usually need to bail out when using SpecConstantOps, but for some very specific cases where we allow unsized arrays currently, we can safely allow "unknown" sized arrays as well. This is probably the best we can do, when we have even more difficult cases than this, we throw a more sensible error message.
2018-11-01 13:56:25 +00:00
packed_size = type_to_packed_size(memb_type, member_flags, packing);
// We only need to care about this if we have non-array types which can straddle the vec4 boundary.
GLSL: Use actual field offset to validate vec4 boundary alignment.
2023-04-25 00:36:44 +00:00
uint32_t actual_offset = type_struct_member_offset(type, i);
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
if (packing_is_hlsl(packing))
{
// If a member straddles across a vec4 boundary, alignment is actually vec4.
HLSL: Fix issue with vec4 straddle rules in substructs.
2024-01-05 13:05:04 +00:00
uint32_t target_offset;
// If we intend to use explicit packing, we must check for improper straddle with that offset.
// In implicit packing, we must check with implicit offset, since the explicit offset
// might have already accounted for the straddle, and we'd miss the alignment promotion to vec4.
// This is important when packing sub-structs that don't support packoffset().
if (packing_has_flexible_offset(packing))
target_offset = actual_offset;
else
target_offset = offset;
uint32_t begin_word = target_offset / 16;
uint32_t end_word = (target_offset + packed_size - 1) / 16;
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
if (begin_word != end_word)
(spirv_glsl.cpp) Fix error: no matching function for call to 'max(uint32_t&, unsigned int)'
2023-01-20 17:36:11 +00:00
packed_alignment = max<uint32_t>(packed_alignment, 16u);
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
}
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
// Field is not in the specified range anymore and we can ignore any further fields.
HLSL: Fix bug in is_packing_standard for cbuffer. Was not keeping offset in sync with actual_offset and HLSL could trigger spurious realignments due to the straddle check.
2020-08-20 13:26:55 +00:00
if (actual_offset >= end_offset)
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
break;
HLSL: Fix bug in is_packing_standard for cbuffer. Was not keeping offset in sync with actual_offset and HLSL could trigger spurious realignments due to the straddle check.
2020-08-20 13:26:55 +00:00
uint32_t alignment = max(packed_alignment, pad_alignment);
offset = (offset + alignment - 1) & ~(alignment - 1);
Handle padding for struct members in buffers. Fixes earlier issues with struct-packing test.
2016-05-05 14:32:15 +00:00
// The next member following a struct member is aligned to the base alignment of the struct that came before.
// GL 4.5 spec, 7.6.2.2.
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
if (memb_type.basetype == SPIRType::Struct && !memb_type.pointer)
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
pad_alignment = packed_alignment;
Handle padding for struct members in buffers. Fixes earlier issues with struct-packing test.
2016-05-05 14:32:15 +00:00
else
pad_alignment = 1;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
// Only care about packing if we are in the given range
HLSL: Fix bug in is_packing_standard for cbuffer. Was not keeping offset in sync with actual_offset and HLSL could trigger spurious realignments due to the straddle check.
2020-08-20 13:26:55 +00:00
if (actual_offset >= start_offset)
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
{
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
// We only care about offsets in std140, std430, etc ...
// For EnhancedLayout variants, we have the flexibility to choose our own offsets.
if (!packing_has_flexible_offset(packing))
{
if (actual_offset != offset) // This cannot be the packing we're looking for.
HLSL: Report more explicitly which member failed validation. This will be awkward to report in GLSL where we check multiple packing standards, but for HLSL it should be easy since there's only CBuffer packing standard to worry about.
2019-11-06 10:20:57 +00:00
{
if (failed_validation_index)
*failed_validation_index = i;
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
return false;
HLSL: Report more explicitly which member failed validation. This will be awkward to report in GLSL where we check multiple packing standards, but for HLSL it should be easy since there's only CBuffer packing standard to worry about.
2019-11-06 10:20:57 +00:00
}
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
}
GLSL/HLSL: Verify member alignment for explicit offset as well.
2019-07-23 09:53:33 +00:00
else if ((actual_offset & (alignment - 1)) != 0)
{
// We still need to verify that alignment rules are observed, even if we have explicit offset.
HLSL: Report more explicitly which member failed validation. This will be awkward to report in GLSL where we check multiple packing standards, but for HLSL it should be easy since there's only CBuffer packing standard to worry about.
2019-11-06 10:20:57 +00:00
if (failed_validation_index)
*failed_validation_index = i;
GLSL/HLSL: Verify member alignment for explicit offset as well.
2019-07-23 09:53:33 +00:00
return false;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
// Verify array stride rules.
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
if (is_array(memb_type) &&
GLSL: Disambiguate pointer vs array properly in packed_size/alignment.
2023-05-10 10:35:47 +00:00
type_to_packed_array_stride(memb_type, member_flags, packing) !=
type_struct_member_array_stride(type, i))
HLSL: Report more explicitly which member failed validation. This will be awkward to report in GLSL where we check multiple packing standards, but for HLSL it should be easy since there's only CBuffer packing standard to worry about.
2019-11-06 10:20:57 +00:00
{
if (failed_validation_index)
*failed_validation_index = i;
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
return false;
HLSL: Report more explicitly which member failed validation. This will be awkward to report in GLSL where we check multiple packing standards, but for HLSL it should be easy since there's only CBuffer packing standard to worry about.
2019-11-06 10:20:57 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
// Verify that sub-structs also follow packing rules.
// We cannot use enhanced layouts on substructs, so they better be up to spec.
auto substruct_packing = packing_to_substruct_packing(packing);
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
if (!memb_type.pointer && !memb_type.member_types.empty() &&
!buffer_is_packing_standard(memb_type, substruct_packing))
{
HLSL: Report more explicitly which member failed validation. This will be awkward to report in GLSL where we check multiple packing standards, but for HLSL it should be easy since there's only CBuffer packing standard to worry about.
2019-11-06 10:20:57 +00:00
if (failed_validation_index)
*failed_validation_index = i;
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
return false;
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
}
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Bump size.
HLSL: Fix bug in is_packing_standard for cbuffer. Was not keeping offset in sync with actual_offset and HLSL could trigger spurious realignments due to the straddle check.
2020-08-20 13:26:55 +00:00
offset = actual_offset + packed_size;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
return true;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Distinguish between enhanced_layouts and SSO requirements. Block locations are 440, but non-block are 410 ...
2018-04-17 12:16:27 +00:00
bool CompilerGLSL::can_use_io_location(StorageClass storage, bool block)
Also check IO location for blocks.
2017-10-19 12:17:18 +00:00
{
// Location specifiers are must have in SPIR-V, but they aren't really supported in earlier versions of GLSL.
// Be very explicit here about how to solve the issue.
if ((get_execution_model() != ExecutionModelVertex && storage == StorageClassInput) ||
(get_execution_model() != ExecutionModelFragment && storage == StorageClassOutput))
{
Distinguish between enhanced_layouts and SSO requirements. Block locations are 440, but non-block are 410 ...
2018-04-17 12:16:27 +00:00
uint32_t minimum_desktop_version = block ? 440 : 410;
// ARB_enhanced_layouts vs ARB_separate_shader_objects ...
if (!options.es && options.version < minimum_desktop_version && !options.separate_shader_objects)
Also check IO location for blocks.
2017-10-19 12:17:18 +00:00
return false;
else if (options.es && options.version < 310)
return false;
}
if ((get_execution_model() == ExecutionModelVertex && storage == StorageClassInput) ||
(get_execution_model() == ExecutionModelFragment && storage == StorageClassOutput))
{
if (options.es && options.version < 300)
return false;
else if (!options.es && options.version < 330)
return false;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
GLSL: Check target version for push constant location = N.
2019-03-19 10:20:25 +00:00
if (storage == StorageClassUniform || storage == StorageClassUniformConstant || storage == StorageClassPushConstant)
Strip uniform locations for ESSL < 3.00 and GLSL < 430
2018-04-07 19:14:35 +00:00
{
if (options.es && options.version < 310)
return false;
else if (!options.es && options.version < 430)
return false;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return true;
Initial commit.
2016-03-02 17:09:16 +00:00
}
string CompilerGLSL::layout_for_variable(const SPIRVariable &var)
{
Comment the workaround for layout_for_variable.
2016-09-21 06:20:04 +00:00
// FIXME: Come up with a better solution for when to disable layouts.
// Having layouts depend on extensions as well as which types
// of layouts are used. For now, the simple solution is to just disable
// layouts for legacy versions.
if (is_legacy())
Do not add layout qualifiers to variables for GLSL versions that don't support it
2016-09-18 04:18:33 +00:00
return "";
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
if (subpass_input_is_framebuffer_fetch(var.self))
return "";
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<string> attr;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &type = get<SPIRType>(var.basetype);
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
auto &flags = get_decoration_bitset(var.self);
auto &typeflags = get_decoration_bitset(type.self);
if (flags.get(DecorationPassthroughNV))
attr.push_back("passthrough");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
if (options.vulkan_semantics && var.storage == StorageClassPushConstant)
attr.push_back("push_constant");
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
else if (var.storage == StorageClassShaderRecordBufferKHR)
attr.push_back(ray_tracing_is_khr ? "shaderRecordEXT" : "shaderRecordNV");
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationRowMajor))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
attr.push_back("row_major");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationColMajor))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
attr.push_back("column_major");
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
if (options.vulkan_semantics)
{
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationInputAttachmentIndex))
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
attr.push_back(join("input_attachment_index = ", get_decoration(var.self, DecorationInputAttachmentIndex)));
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
}
Distinguish between enhanced_layouts and SSO requirements. Block locations are 440, but non-block are 410 ...
2018-04-17 12:16:27 +00:00
bool is_block = has_decoration(type.self, DecorationBlock);
if (flags.get(DecorationLocation) && can_use_io_location(var.storage, is_block))
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
{
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
Bitset combined_decoration;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
for (uint32_t i = 0; i < ir.meta[type.self].members.size(); i++)
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
combined_decoration.merge_or(combined_decoration_for_member(type, i));
Do not emit layout(location) qualifiers for older GLSL targets. ESSL 300 and GLSL <410 do not support this along with legacy targets.
2017-07-31 09:17:02 +00:00
Also check IO location for blocks.
2017-10-19 12:17:18 +00:00
// If our members have location decorations, we don't need to
// emit location decorations at the top as well (looks weird).
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (!combined_decoration.get(DecorationLocation))
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
attr.push_back(join("location = ", get_decoration(var.self, DecorationLocation)));
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
}
Always emit DescriptorSet decoration for Vulkan GLSL.
2016-05-05 09:51:18 +00:00
GLSL: Implement noncoherent framebuffer fetch.
2021-05-21 12:21:13 +00:00
if (get_execution_model() == ExecutionModelFragment && var.storage == StorageClassOutput &&
location_is_non_coherent_framebuffer_fetch(get_decoration(var.self, DecorationLocation)))
{
attr.push_back("noncoherent");
}
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
// Transform feedback
bool uses_enhanced_layouts = false;
if (is_block && var.storage == StorageClassOutput)
{
// For blocks, there is a restriction where xfb_stride/xfb_buffer must only be declared on the block itself,
// since all members must match the same xfb_buffer. The only thing we will declare for members of the block
// is the xfb_offset.
uint32_t member_count = uint32_t(type.member_types.size());
bool have_xfb_buffer_stride = false;
bool have_any_xfb_offset = false;
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
bool have_geom_stream = false;
uint32_t xfb_stride = 0, xfb_buffer = 0, geom_stream = 0;
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
if (flags.get(DecorationXfbBuffer) && flags.get(DecorationXfbStride))
{
have_xfb_buffer_stride = true;
xfb_buffer = get_decoration(var.self, DecorationXfbBuffer);
xfb_stride = get_decoration(var.self, DecorationXfbStride);
}
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
if (flags.get(DecorationStream))
{
have_geom_stream = true;
geom_stream = get_decoration(var.self, DecorationStream);
}
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
// Verify that none of the members violate our assumption.
for (uint32_t i = 0; i < member_count; i++)
{
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
if (has_member_decoration(type.self, i, DecorationStream))
{
uint32_t member_geom_stream = get_member_decoration(type.self, i, DecorationStream);
if (have_geom_stream && member_geom_stream != geom_stream)
SPIRV_CROSS_THROW("IO block member Stream mismatch.");
have_geom_stream = true;
geom_stream = member_geom_stream;
}
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
// Only members with an Offset decoration participate in XFB.
if (!has_member_decoration(type.self, i, DecorationOffset))
continue;
have_any_xfb_offset = true;
if (has_member_decoration(type.self, i, DecorationXfbBuffer))
{
uint32_t buffer_index = get_member_decoration(type.self, i, DecorationXfbBuffer);
if (have_xfb_buffer_stride && buffer_index != xfb_buffer)
SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch.");
have_xfb_buffer_stride = true;
xfb_buffer = buffer_index;
}
if (has_member_decoration(type.self, i, DecorationXfbStride))
{
uint32_t stride = get_member_decoration(type.self, i, DecorationXfbStride);
if (have_xfb_buffer_stride && stride != xfb_stride)
SPIRV_CROSS_THROW("IO block member XfbStride mismatch.");
have_xfb_buffer_stride = true;
xfb_stride = stride;
}
}
if (have_xfb_buffer_stride && have_any_xfb_offset)
{
attr.push_back(join("xfb_buffer = ", xfb_buffer));
attr.push_back(join("xfb_stride = ", xfb_stride));
uses_enhanced_layouts = true;
}
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
if (have_geom_stream)
{
if (get_execution_model() != ExecutionModelGeometry)
SPIRV_CROSS_THROW("Geometry streams can only be used in geometry shaders.");
if (options.es)
SPIRV_CROSS_THROW("Multiple geometry streams not supported in ESSL.");
if (options.version < 400)
require_extension_internal("GL_ARB_transform_feedback3");
attr.push_back(join("stream = ", get_decoration(var.self, DecorationStream)));
}
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
}
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
else if (var.storage == StorageClassOutput)
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
{
Run format_all.sh.
2020-11-08 12:59:52 +00:00
if (flags.get(DecorationXfbBuffer) && flags.get(DecorationXfbStride) && flags.get(DecorationOffset))
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
{
// XFB for standalone variables, we can emit all decorations.
attr.push_back(join("xfb_buffer = ", get_decoration(var.self, DecorationXfbBuffer)));
attr.push_back(join("xfb_stride = ", get_decoration(var.self, DecorationXfbStride)));
attr.push_back(join("xfb_offset = ", get_decoration(var.self, DecorationOffset)));
uses_enhanced_layouts = true;
}
if (flags.get(DecorationStream))
{
if (get_execution_model() != ExecutionModelGeometry)
SPIRV_CROSS_THROW("Geometry streams can only be used in geometry shaders.");
if (options.es)
SPIRV_CROSS_THROW("Multiple geometry streams not supported in ESSL.");
if (options.version < 400)
require_extension_internal("GL_ARB_transform_feedback3");
attr.push_back(join("stream = ", get_decoration(var.self, DecorationStream)));
}
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
}
Support Component decoration in GLSL.
2018-09-10 10:13:26 +00:00
// Can only declare Component if we can declare location.
if (flags.get(DecorationComponent) && can_use_io_location(var.storage, is_block))
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
{
uses_enhanced_layouts = true;
attr.push_back(join("component = ", get_decoration(var.self, DecorationComponent)));
}
if (uses_enhanced_layouts)
Support Component decoration in GLSL.
2018-09-10 10:13:26 +00:00
{
if (!options.es)
{
if (options.version < 440 && options.version >= 140)
require_extension_internal("GL_ARB_enhanced_layouts");
else if (options.version < 140)
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
SPIRV_CROSS_THROW("GL_ARB_enhanced_layouts is not supported in targets below GLSL 1.40.");
if (!options.es && options.version < 440)
require_extension_internal("GL_ARB_enhanced_layouts");
Support Component decoration in GLSL.
2018-09-10 10:13:26 +00:00
}
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
else if (options.es)
SPIRV_CROSS_THROW("GL_ARB_enhanced_layouts is not supported in ESSL.");
Support Component decoration in GLSL.
2018-09-10 10:13:26 +00:00
}
Support dual-source blending on GLSL and MSL.
2018-04-03 13:56:22 +00:00
if (flags.get(DecorationIndex))
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
attr.push_back(join("index = ", get_decoration(var.self, DecorationIndex)));
Support dual-source blending on GLSL and MSL.
2018-04-03 13:56:22 +00:00
Various maintenance fixes. - Do not emit set = in GLSL, even when non-zero. - Fix warning on tautological comparison. - Expose get_buffer_block_flags as mentioned in reflection guide.
2018-06-03 10:00:22 +00:00
// Do not emit set = decoration in regular GLSL output, but
// we need to preserve it in Vulkan GLSL mode.
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
if (var.storage != StorageClassPushConstant && var.storage != StorageClassShaderRecordBufferKHR)
Always emit DescriptorSet decoration for Vulkan GLSL.
2016-05-05 09:51:18 +00:00
{
Various maintenance fixes. - Do not emit set = in GLSL, even when non-zero. - Fix warning on tautological comparison. - Expose get_buffer_block_flags as mentioned in reflection guide.
2018-06-03 10:00:22 +00:00
if (flags.get(DecorationDescriptorSet) && options.vulkan_semantics)
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
attr.push_back(join("set = ", get_decoration(var.self, DecorationDescriptorSet)));
Always emit DescriptorSet decoration for Vulkan GLSL.
2016-05-05 09:51:18 +00:00
}
GLSL: Add option to disable buffer blocks regardless of version
2019-05-11 14:30:33 +00:00
bool push_constant_block = options.vulkan_semantics && var.storage == StorageClassPushConstant;
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
bool ssbo_block = var.storage == StorageClassStorageBuffer || var.storage == StorageClassShaderRecordBufferKHR ||
GLSL: Add option to disable buffer blocks regardless of version
2019-05-11 14:30:33 +00:00
(var.storage == StorageClassUniform && typeflags.get(DecorationBufferBlock));
bool emulated_ubo = var.storage == StorageClassPushConstant && options.emit_push_constant_as_uniform_buffer;
bool ubo_block = var.storage == StorageClassUniform && typeflags.get(DecorationBlock);
Emit classic uniform for UBO in GLSL 1.30.
2018-04-03 14:46:58 +00:00
// GL 3.0/GLSL 1.30 is not considered legacy, but it doesn't have UBOs ...
bool can_use_buffer_blocks = (options.es && options.version >= 300) || (!options.es && options.version >= 140);
Run format_all.sh.
2019-05-14 07:54:35 +00:00
// pretend no UBOs when options say so
GLSL: Add option to disable buffer blocks regardless of version
2019-05-11 14:30:33 +00:00
if (ubo_block && options.emit_uniform_buffer_as_plain_uniforms)
can_use_buffer_blocks = false;
Add option to disable use of 420pack extension.
2017-09-08 07:56:06 +00:00
bool can_use_binding;
if (options.es)
can_use_binding = options.version >= 310;
else
can_use_binding = options.enable_420pack_extension || (options.version >= 420);
Only disable binding layout for UBOs.
2018-04-03 14:58:05 +00:00
// Make sure we don't emit binding layout for a classic uniform on GLSL 1.30.
if (!can_use_buffer_blocks && var.storage == StorageClassUniform)
Emit classic uniform for UBO in GLSL 1.30.
2018-04-03 14:46:58 +00:00
can_use_binding = false;
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
if (var.storage == StorageClassShaderRecordBufferKHR)
Fix storage packing qualifiers missing on "shaderRecordNV" buffers
2019-06-05 11:29:01 +00:00
can_use_binding = false;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (can_use_binding && flags.get(DecorationBinding))
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
attr.push_back(join("binding = ", get_decoration(var.self, DecorationBinding)));
Add option to disable use of 420pack extension.
2017-09-08 07:56:06 +00:00
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
if (var.storage != StorageClassOutput && flags.get(DecorationOffset))
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
attr.push_back(join("offset = ", get_decoration(var.self, DecorationOffset)));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Instead of adding explicit offsets for every element here, just assume we're using std140 or std430.
// If SPIR-V does not comply with either layout, we cannot really work around it.
GLSL: Support emitting push constant block as a plain UBO.
2019-03-19 09:58:37 +00:00
if (can_use_buffer_blocks && (ubo_block || emulated_ubo))
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
{
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
attr.push_back(buffer_to_packing_standard(type, false, true));
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
}
Emit classic uniform for UBO in GLSL 1.30.
2018-04-03 14:46:58 +00:00
else if (can_use_buffer_blocks && (push_constant_block || ssbo_block))
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
{
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
attr.push_back(buffer_to_packing_standard(type, true, true));
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// For images, the type itself adds a layout qualifer.
Fix case where samplerBuffer is emitted without combined sampler.
2017-04-02 08:54:11 +00:00
// Only emit the format for storage images.
if (type.basetype == SPIRType::Image && type.image.sampled == 2)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
const char *fmt = format_to_glsl(type.image.format);
if (fmt)
attr.push_back(fmt);
}
if (attr.empty())
return "";
string res = "layout(";
res += merge(attr);
res += ") ";
return res;
Initial commit.
2016-03-02 17:09:16 +00:00
}
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
string CompilerGLSL::buffer_to_packing_standard(const SPIRType &type,
bool support_std430_without_scalar_layout,
bool support_enhanced_layouts)
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
GLSL: Support std430 in UBOs with scalar layout.
2019-05-28 10:21:08 +00:00
if (support_std430_without_scalar_layout && buffer_is_packing_standard(type, BufferPackingStd430))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
return "std430";
else if (buffer_is_packing_standard(type, BufferPackingStd140))
return "std140";
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
else if (options.vulkan_semantics && buffer_is_packing_standard(type, BufferPackingScalar))
{
require_extension_internal("GL_EXT_scalar_block_layout");
return "scalar";
}
GLSL: Support std430 in UBOs with scalar layout.
2019-05-28 10:21:08 +00:00
else if (support_std430_without_scalar_layout &&
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
support_enhanced_layouts &&
GLSL: Support std430 in UBOs with scalar layout.
2019-05-28 10:21:08 +00:00
buffer_is_packing_standard(type, BufferPackingStd430EnhancedLayout))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
if (options.es && !options.vulkan_semantics)
SPIRV_CROSS_THROW("Push constant block cannot be expressed as neither std430 nor std140. ES-targets do "
"not support GL_ARB_enhanced_layouts.");
if (!options.es && !options.vulkan_semantics && options.version < 440)
require_extension_internal("GL_ARB_enhanced_layouts");
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset);
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
return "std430";
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
}
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
else if (support_enhanced_layouts &&
buffer_is_packing_standard(type, BufferPackingStd140EnhancedLayout))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
// Fallback time. We might be able to use the ARB_enhanced_layouts to deal with this difference,
// however, we can only use layout(offset) on the block itself, not any substructs, so the substructs better be the appropriate layout.
// Enhanced layouts seem to always work in Vulkan GLSL, so no need for extensions there.
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
if (options.es && !options.vulkan_semantics)
SPIRV_CROSS_THROW("Push constant block cannot be expressed as neither std430 nor std140. ES-targets do "
"not support GL_ARB_enhanced_layouts.");
if (!options.es && !options.vulkan_semantics && options.version < 440)
require_extension_internal("GL_ARB_enhanced_layouts");
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset);
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
return "std140";
}
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
else if (options.vulkan_semantics &&
support_enhanced_layouts &&
buffer_is_packing_standard(type, BufferPackingScalarEnhancedLayout))
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset);
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
require_extension_internal("GL_EXT_scalar_block_layout");
return "scalar";
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
}
GLSL: Support std430 in UBOs with scalar layout.
2019-05-28 10:21:08 +00:00
else if (!support_std430_without_scalar_layout && options.vulkan_semantics &&
buffer_is_packing_standard(type, BufferPackingStd430))
{
// UBOs can support std430 with GL_EXT_scalar_block_layout.
require_extension_internal("GL_EXT_scalar_block_layout");
return "std430";
}
else if (!support_std430_without_scalar_layout && options.vulkan_semantics &&
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
support_enhanced_layouts &&
GLSL: Support std430 in UBOs with scalar layout.
2019-05-28 10:21:08 +00:00
buffer_is_packing_standard(type, BufferPackingStd430EnhancedLayout))
{
// UBOs can support std430 with GL_EXT_scalar_block_layout.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
set_extended_decoration(type.self, SPIRVCrossDecorationExplicitOffset);
GLSL: Support std430 in UBOs with scalar layout.
2019-05-28 10:21:08 +00:00
require_extension_internal("GL_EXT_scalar_block_layout");
return "std430";
}
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
else
{
GLSL: Support GL_EXT_scalar_block_layout.
2019-04-26 11:05:44 +00:00
SPIRV_CROSS_THROW("Buffer block cannot be expressed as any of std430, std140, scalar, even with enhanced "
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
"layouts. You can try flattening this block to support a more flexible layout.");
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::emit_push_constant_block(const SPIRVariable &var)
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
{
Add flattening support for push constants.
2017-01-21 09:27:14 +00:00
if (flattened_buffer_blocks.count(var.self))
emit_buffer_block_flattened(var);
else if (options.vulkan_semantics)
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
emit_push_constant_block_vulkan(var);
GLSL: Support emitting push constant block as a plain UBO.
2019-03-19 09:58:37 +00:00
else if (options.emit_push_constant_as_uniform_buffer)
emit_buffer_block_native(var);
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
else
emit_push_constant_block_glsl(var);
}
void CompilerGLSL::emit_push_constant_block_vulkan(const SPIRVariable &var)
{
emit_buffer_block(var);
}
void CompilerGLSL::emit_push_constant_block_glsl(const SPIRVariable &var)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// OpenGL has no concept of push constant blocks, implement it as a uniform struct.
auto &type = get<SPIRType>(var.basetype);
Initial commit.
2016-03-02 17:09:16 +00:00
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
unset_decoration(var.self, DecorationBinding);
unset_decoration(var.self, DecorationDescriptorSet);
Initial commit.
2016-03-02 17:09:16 +00:00
#if 0
if (flags & ((1ull << DecorationBinding) | (1ull << DecorationDescriptorSet)))
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Push constant blocks cannot be compiled to GLSL with Binding or Set syntax. "
Initial commit.
2016-03-02 17:09:16 +00:00
"Remap to location with reflection API first or disable these decorations.");
#endif
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// We're emitting the push constant block as a regular struct, so disable the block qualifier temporarily.
// Otherwise, we will end up emitting layout() qualifiers on naked structs which is not allowed.
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
bool block_flag = has_decoration(type.self, DecorationBlock);
unset_decoration(type.self, DecorationBlock);
Initial commit.
2016-03-02 17:09:16 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_struct(type);
Initial commit.
2016-03-02 17:09:16 +00:00
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (block_flag)
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
set_decoration(type.self, DecorationBlock);
Initial commit.
2016-03-02 17:09:16 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_uniform(var);
statement("");
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::emit_buffer_block(const SPIRVariable &var)
Minor emit_buffer_block refactoring Move buffer block variant dispatch into emit_buffer_block to match emit_push_constant_block, move SSBO check into emit_buffer_block_legacy.
2017-01-17 20:18:35 +00:00
{
GLSL: Add option to disable buffer blocks regardless of version
2019-05-11 14:30:33 +00:00
auto &type = get<SPIRType>(var.basetype);
Run format_all.sh.
2019-05-14 07:54:35 +00:00
bool ubo_block = var.storage == StorageClassUniform && has_decoration(type.self, DecorationBlock);
GLSL: Add option to disable buffer blocks regardless of version
2019-05-11 14:30:33 +00:00
Minor emit_buffer_block refactoring Move buffer block variant dispatch into emit_buffer_block to match emit_push_constant_block, move SSBO check into emit_buffer_block_legacy.
2017-01-17 20:18:35 +00:00
if (flattened_buffer_blocks.count(var.self))
emit_buffer_block_flattened(var);
Run format_all.sh.
2019-05-14 07:54:35 +00:00
else if (is_legacy() || (!options.es && options.version == 130) ||
(ubo_block && options.emit_uniform_buffer_as_plain_uniforms))
Minor emit_buffer_block refactoring Move buffer block variant dispatch into emit_buffer_block to match emit_push_constant_block, move SSBO check into emit_buffer_block_legacy.
2017-01-17 20:18:35 +00:00
emit_buffer_block_legacy(var);
else
emit_buffer_block_native(var);
}
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
void CompilerGLSL::emit_buffer_block_legacy(const SPIRVariable &var)
{
auto &type = get<SPIRType>(var.basetype);
Add basic support for StorageClassStorageBuffer. Needs more testing, but seems to work.
2017-09-28 11:28:44 +00:00
bool ssbo = var.storage == StorageClassStorageBuffer ||
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock);
Minor emit_buffer_block refactoring Move buffer block variant dispatch into emit_buffer_block to match emit_push_constant_block, move SSBO check into emit_buffer_block_legacy.
2017-01-17 20:18:35 +00:00
if (ssbo)
SPIRV_CROSS_THROW("SSBOs not supported in legacy targets.");
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
// We're emitting the push constant block as a regular struct, so disable the block qualifier temporarily.
// Otherwise, we will end up emitting layout() qualifiers on naked structs which is not allowed.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &block_flags = ir.meta[type.self].decoration.decoration_flags;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
bool block_flag = block_flags.get(DecorationBlock);
block_flags.clear(DecorationBlock);
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
emit_struct(type);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (block_flag)
block_flags.set(DecorationBlock);
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
emit_uniform(var);
statement("");
}
GLSL: Deal with buffer_reference_align. This is somewhat awkward to support, but the best effort we can do here is to analyze various Load/Store opcodes and deduce the ideal overall alignment based on this. This is not a 100% perfect solution, but should be correct for any reasonable use case. Also fix various nitpicks with BDA support while I'm at it.
2021-11-07 14:43:57 +00:00
void CompilerGLSL::emit_buffer_reference_block(uint32_t type_id, bool forward_declaration)
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
GLSL: Deal with buffer_reference_align. This is somewhat awkward to support, but the best effort we can do here is to analyze various Load/Store opcodes and deduce the ideal overall alignment based on this. This is not a 100% perfect solution, but should be correct for any reasonable use case. Also fix various nitpicks with BDA support while I'm at it.
2021-11-07 14:43:57 +00:00
auto &type = get<SPIRType>(type_id);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
string buffer_name;
GLSL: Forward declare non-block BDA types as well. With non-block structs, we can have pointers in those types too.
2024-01-18 11:56:31 +00:00
if (forward_declaration && is_physical_pointer_to_buffer_block(type))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
// Block names should never alias, but from HLSL input they kind of can because block types are reused for UAVs ...
// Allow aliased name since we might be declaring the block twice. Once with buffer reference (forward declared) and one proper declaration.
// The names must match up.
buffer_name = to_name(type.self, false);
// Shaders never use the block by interface name, so we don't
// have to track this other than updating name caches.
// If we have a collision for any reason, just fallback immediately.
if (ir.meta[type.self].decoration.alias.empty() ||
block_ssbo_names.find(buffer_name) != end(block_ssbo_names) ||
resource_names.find(buffer_name) != end(resource_names))
{
buffer_name = join("_", type.self);
}
// Make sure we get something unique for both global name scope and block name scope.
// See GLSL 4.5 spec: section 4.3.9 for details.
add_variable(block_ssbo_names, resource_names, buffer_name);
// If for some reason buffer_name is an illegal name, make a final fallback to a workaround name.
// This cannot conflict with anything else, so we're safe now.
// We cannot reuse this fallback name in neither global scope (blocked by block_names) nor block name scope.
if (buffer_name.empty())
buffer_name = join("_", type.self);
block_names.insert(buffer_name);
block_ssbo_names.insert(buffer_name);
GLSL: Fix buffer_reference with aliased names.
2020-11-23 15:36:49 +00:00
// Ensure we emit the correct name when emitting non-forward pointer type.
ir.meta[type.self].decoration.alias = buffer_name;
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
}
else
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
{
buffer_name = type_to_glsl(type);
}
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
if (!forward_declaration)
{
GLSL: Deal with buffer_reference_align. This is somewhat awkward to support, but the best effort we can do here is to analyze various Load/Store opcodes and deduce the ideal overall alignment based on this. This is not a 100% perfect solution, but should be correct for any reasonable use case. Also fix various nitpicks with BDA support while I'm at it.
2021-11-07 14:43:57 +00:00
auto itr = physical_storage_type_to_alignment.find(type_id);
uint32_t alignment = 0;
if (itr != physical_storage_type_to_alignment.end())
alignment = itr->second.alignment;
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
if (is_physical_pointer_to_buffer_block(type))
GLSL: Emit storage qualifiers for buffer_reference.
2020-11-23 15:26:33 +00:00
{
GLSL: Deal with buffer_reference_align. This is somewhat awkward to support, but the best effort we can do here is to analyze various Load/Store opcodes and deduce the ideal overall alignment based on this. This is not a 100% perfect solution, but should be correct for any reasonable use case. Also fix various nitpicks with BDA support while I'm at it.
2021-11-07 14:43:57 +00:00
SmallVector<std::string> attributes;
attributes.push_back("buffer_reference");
if (alignment)
attributes.push_back(join("buffer_reference_align = ", alignment));
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
attributes.push_back(buffer_to_packing_standard(type, true, true));
GLSL: Deal with buffer_reference_align. This is somewhat awkward to support, but the best effort we can do here is to analyze various Load/Store opcodes and deduce the ideal overall alignment based on this. This is not a 100% perfect solution, but should be correct for any reasonable use case. Also fix various nitpicks with BDA support while I'm at it.
2021-11-07 14:43:57 +00:00
GLSL: Emit storage qualifiers for buffer_reference.
2020-11-23 15:26:33 +00:00
auto flags = ir.get_buffer_block_type_flags(type);
string decorations;
if (flags.get(DecorationRestrict))
decorations += " restrict";
if (flags.get(DecorationCoherent))
decorations += " coherent";
if (flags.get(DecorationNonReadable))
decorations += " writeonly";
if (flags.get(DecorationNonWritable))
decorations += " readonly";
GLSL: Deal with buffer_reference_align. This is somewhat awkward to support, but the best effort we can do here is to analyze various Load/Store opcodes and deduce the ideal overall alignment based on this. This is not a 100% perfect solution, but should be correct for any reasonable use case. Also fix various nitpicks with BDA support while I'm at it.
2021-11-07 14:43:57 +00:00
statement("layout(", merge(attributes), ")", decorations, " buffer ", buffer_name);
GLSL: Emit storage qualifiers for buffer_reference.
2020-11-23 15:26:33 +00:00
}
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
else
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
{
string packing_standard;
if (type.basetype == SPIRType::Struct)
{
// The non-block type is embedded in a block, so we cannot use enhanced layouts :(
packing_standard = buffer_to_packing_standard(type, true, false) + ", ";
}
GLSL: Handle ptr-to-array casts with unexpected array strides.
2024-01-18 13:14:10 +00:00
else if (is_array(get_pointee_type(type)))
{
SPIRType wrap_type{OpTypeStruct};
wrap_type.self = ir.increase_bound_by(1);
wrap_type.member_types.push_back(get_pointee_type_id(type_id));
ir.set_member_decoration(wrap_type.self, 0, DecorationOffset, 0);
packing_standard = buffer_to_packing_standard(wrap_type, true, false) + ", ";
}
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
if (alignment)
statement("layout(", packing_standard, "buffer_reference, buffer_reference_align = ", alignment, ") buffer ", buffer_name);
else
statement("layout(", packing_standard, "buffer_reference) buffer ", buffer_name);
}
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
begin_scope();
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
if (is_physical_pointer_to_buffer_block(type))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
type.member_name_cache.clear();
uint32_t i = 0;
for (auto &member : type.member_types)
{
add_member_name(type, i);
emit_struct_member(type, member, i);
i++;
}
}
else
{
auto &pointee_type = get_pointee_type(type);
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
statement(type_to_glsl(pointee_type), " value", type_to_array_glsl(pointee_type, 0), ";");
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
}
end_scope_decl();
statement("");
}
else
{
statement("layout(buffer_reference) buffer ", buffer_name, ";");
}
}
Minor emit_buffer_block refactoring Move buffer block variant dispatch into emit_buffer_block to match emit_push_constant_block, move SSBO check into emit_buffer_block_legacy.
2017-01-17 20:18:35 +00:00
void CompilerGLSL::emit_buffer_block_native(const SPIRVariable &var)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &type = get<SPIRType>(var.basetype);
Emit readonly, writeonly for SSBOs.
2017-01-21 09:07:38 +00:00
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
Bitset flags = ir.get_buffer_block_flags(var);
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
bool ssbo = var.storage == StorageClassStorageBuffer || var.storage == StorageClassShaderRecordBufferKHR ||
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
bool is_restrict = ssbo && flags.get(DecorationRestrict);
bool is_writeonly = ssbo && flags.get(DecorationNonReadable);
bool is_readonly = ssbo && flags.get(DecorationNonWritable);
bool is_coherent = ssbo && flags.get(DecorationCoherent);
Do not rely on OpName when finding OpTypeStruct aliases. SPIR-V can stamp out multiple variants of the same types to deal with different offsets, layouts, array strides and so on in buffer blocks.
2016-05-23 08:57:22 +00:00
Improve handling of block name declaration in GLSL. HLSL UAVs are a bit annoying because they can share block types, so reflection becomes rather awkward. Sometimes we will need to make some nasty fallbacks, so add a reflection interface which lets you query post-shader compile which names was actually declared in the shader.
2017-12-01 13:20:51 +00:00
// Block names should never alias, but from HLSL input they kind of can because block types are reused for UAVs ...
Do not rely on OpName when finding OpTypeStruct aliases. SPIR-V can stamp out multiple variants of the same types to deal with different offsets, layouts, array strides and so on in buffer blocks.
2016-05-23 08:57:22 +00:00
auto buffer_name = to_name(type.self, false);
GLSL: Allow blocks to have their own namespace.
2018-08-21 09:29:08 +00:00
auto &block_namespace = ssbo ? block_ssbo_names : block_ubo_names;
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
// Shaders never use the block by interface name, so we don't
// have to track this other than updating name caches.
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
// If we have a collision for any reason, just fallback immediately.
Run format_all.sh.
2019-01-07 09:01:28 +00:00
if (ir.meta[type.self].decoration.alias.empty() || block_namespace.find(buffer_name) != end(block_namespace) ||
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
resource_names.find(buffer_name) != end(resource_names))
{
Add WorkGroupID/NumWorkGroups to MSL. Fix block name alias.
2017-09-29 10:16:53 +00:00
buffer_name = get_block_fallback_name(var.self);
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
}
Improve handling of block name declaration in GLSL. HLSL UAVs are a bit annoying because they can share block types, so reflection becomes rather awkward. Sometimes we will need to make some nasty fallbacks, so add a reflection interface which lets you query post-shader compile which names was actually declared in the shader.
2017-12-01 13:20:51 +00:00
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
// Make sure we get something unique for both global name scope and block name scope.
// See GLSL 4.5 spec: section 4.3.9 for details.
add_variable(block_namespace, resource_names, buffer_name);
Improve handling of block name declaration in GLSL. HLSL UAVs are a bit annoying because they can share block types, so reflection becomes rather awkward. Sometimes we will need to make some nasty fallbacks, so add a reflection interface which lets you query post-shader compile which names was actually declared in the shader.
2017-12-01 13:20:51 +00:00
// If for some reason buffer_name is an illegal name, make a final fallback to a workaround name.
// This cannot conflict with anything else, so we're safe now.
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
// We cannot reuse this fallback name in neither global scope (blocked by block_names) nor block name scope.
Improve handling of block name declaration in GLSL. HLSL UAVs are a bit annoying because they can share block types, so reflection becomes rather awkward. Sometimes we will need to make some nasty fallbacks, so add a reflection interface which lets you query post-shader compile which names was actually declared in the shader.
2017-12-01 13:20:51 +00:00
if (buffer_name.empty())
buffer_name = join("_", get<SPIRType>(var.basetype).self, "_", var.self);
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
block_names.insert(buffer_name);
block_namespace.insert(buffer_name);
GLSL: Allow blocks to have their own namespace.
2018-08-21 09:29:08 +00:00
Improve handling of block name declaration in GLSL. HLSL UAVs are a bit annoying because they can share block types, so reflection becomes rather awkward. Sometimes we will need to make some nasty fallbacks, so add a reflection interface which lets you query post-shader compile which names was actually declared in the shader.
2017-12-01 13:20:51 +00:00
// Save for post-reflection later.
declared_block_names[var.self] = buffer_name;
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
Run format_all.sh.
2017-08-28 07:01:03 +00:00
statement(layout_for_variable(var), is_coherent ? "coherent " : "", is_restrict ? "restrict " : "",
is_writeonly ? "writeonly " : "", is_readonly ? "readonly " : "", ssbo ? "buffer " : "uniform ",
buffer_name);
Emit readonly, writeonly for SSBOs.
2017-01-21 09:07:38 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
begin_scope();
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
type.member_name_cache.clear();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t i = 0;
for (auto &member : type.member_types)
{
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
add_member_name(type, i);
Updates to MSL functionality to support PR review feedback.
2017-03-11 17:17:22 +00:00
emit_struct_member(type, member, i);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
i++;
}
GLSL: Handle empty block declarations. Similar fix as for structs.
2023-10-11 11:03:21 +00:00
// Don't declare empty blocks in GLSL, this is not allowed.
if (type_is_empty(type) && !backend.supports_empty_struct)
statement("int empty_struct_member;");
GLSL: Fix block name shenanigans in edge cases. When we force recompile, the old var.self name we used as a fallback name might have been disturbed, so we should recover certain names back to their original form in case we are forced to take a recompile to make the naming algorithm more deterministic.
2019-02-13 15:39:59 +00:00
// var.self can be used as a backup name for the block name,
// so we need to make sure we don't disturb the name here on a recompile.
// It will need to be reset if we have to recompile.
preserve_alias_on_reset(var.self);
Improve handling of block name declaration in GLSL. HLSL UAVs are a bit annoying because they can share block types, so reflection becomes rather awkward. Sometimes we will need to make some nasty fallbacks, so add a reflection interface which lets you query post-shader compile which names was actually declared in the shader.
2017-12-01 13:20:51 +00:00
add_resource_name(var.self);
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
end_scope_decl(to_name(var.self) + type_to_array_glsl(type, var.self));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Minor emit_buffer_block refactoring Move buffer block variant dispatch into emit_buffer_block to match emit_push_constant_block, move SSBO check into emit_buffer_block_legacy.
2017-01-17 20:18:35 +00:00
void CompilerGLSL::emit_buffer_block_flattened(const SPIRVariable &var)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
auto &type = get<SPIRType>(var.basetype);
// Block names should never alias.
auto buffer_name = to_name(type.self, false);
size_t buffer_size = (get_declared_struct_size(type) + 15) / 16;
Support int and uint as flattened UBO types.
2017-01-21 11:29:20 +00:00
SPIRType::BaseType basic_type;
if (get_common_basic_type(type, basic_type))
{
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType tmp { OpTypeVector };
Support int and uint as flattened UBO types.
2017-01-21 11:29:20 +00:00
tmp.basetype = basic_type;
Cleanup emit_buffer_block_flattened.
2017-01-22 07:53:52 +00:00
tmp.vecsize = 4;
if (basic_type != SPIRType::Float && basic_type != SPIRType::Int && basic_type != SPIRType::UInt)
Support int and uint as flattened UBO types.
2017-01-21 11:29:20 +00:00
SPIRV_CROSS_THROW("Basic types in a flattened UBO must be float, int or uint.");
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto flags = ir.get_buffer_block_flags(var);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
statement("uniform ", flags_to_qualifiers_glsl(tmp, flags), type_to_glsl(tmp), " ", buffer_name, "[",
Comment type ID a bit better.
2017-01-22 08:06:15 +00:00
buffer_size, "];");
Support int and uint as flattened UBO types.
2017-01-21 11:29:20 +00:00
}
else
SPIRV_CROSS_THROW("All basic types in a flattened block must be the same.");
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
Emit storage qualifier in the correct place. Need to emit qualifiers in a specific order for legacy GLSL. <interpolation> <storage> <precision> <type>.
2017-02-24 08:56:17 +00:00
const char *CompilerGLSL::to_storage_qualifiers_glsl(const SPIRVariable &var)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add support for multiple entry points. - Only consider I/O variables if part of OpEntryPoint. - Keep a safe fallback if #entry-points is 1 to avoid potentially breaking previously working shaders.
2016-07-28 09:16:02 +00:00
auto &execution = get_entry_point();
Emit storage qualifier in the correct place. Need to emit qualifiers in a specific order for legacy GLSL. <interpolation> <storage> <precision> <type>.
2017-02-24 08:56:17 +00:00
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
if (subpass_input_is_framebuffer_fetch(var.self))
return "";
Emit storage qualifier in the correct place. Need to emit qualifiers in a specific order for legacy GLSL. <interpolation> <storage> <precision> <type>.
2017-02-24 08:56:17 +00:00
if (var.storage == StorageClassInput || var.storage == StorageClassOutput)
{
if (is_legacy() && execution.model == ExecutionModelVertex)
return var.storage == StorageClassInput ? "attribute " : "varying ";
else if (is_legacy() && execution.model == ExecutionModelFragment)
return "varying "; // Fragment outputs are renamed so they never hit this case.
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
else if (execution.model == ExecutionModelFragment && var.storage == StorageClassOutput)
{
GLSL: Implement noncoherent framebuffer fetch.
2021-05-21 12:21:13 +00:00
uint32_t loc = get_decoration(var.self, DecorationLocation);
bool is_inout = location_is_framebuffer_fetch(loc);
if (is_inout)
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
return "inout ";
else
return "out ";
}
Emit storage qualifier in the correct place. Need to emit qualifiers in a specific order for legacy GLSL. <interpolation> <storage> <precision> <type>.
2017-02-24 08:56:17 +00:00
else
return var.storage == StorageClassInput ? "in " : "out ";
}
else if (var.storage == StorageClassUniformConstant || var.storage == StorageClassUniform ||
GLSL: Fix atomic_uint being incorrectly generated as uint
2024-02-23 01:33:08 +00:00
var.storage == StorageClassPushConstant || var.storage == StorageClassAtomicCounter)
Emit storage qualifier in the correct place. Need to emit qualifiers in a specific order for legacy GLSL. <interpolation> <storage> <precision> <type>.
2017-02-24 08:56:17 +00:00
{
return "uniform ";
}
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
else if (var.storage == StorageClassRayPayloadKHR)
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
{
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
return ray_tracing_is_khr ? "rayPayloadEXT " : "rayPayloadNV ";
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
}
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
else if (var.storage == StorageClassIncomingRayPayloadKHR)
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
{
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
return ray_tracing_is_khr ? "rayPayloadInEXT " : "rayPayloadInNV ";
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
}
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
else if (var.storage == StorageClassHitAttributeKHR)
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
{
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
return ray_tracing_is_khr ? "hitAttributeEXT " : "hitAttributeNV ";
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
}
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
else if (var.storage == StorageClassCallableDataKHR)
Add support for "shaderRecordNV" qualifier
2019-06-03 13:25:21 +00:00
{
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
return ray_tracing_is_khr ? "callableDataEXT " : "callableDataNV ";
Add support for "shaderRecordNV" qualifier
2019-06-03 13:25:21 +00:00
}
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
else if (var.storage == StorageClassIncomingCallableDataKHR)
Add support for "shaderRecordNV" qualifier
2019-06-03 13:25:21 +00:00
{
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
return ray_tracing_is_khr ? "callableDataInEXT " : "callableDataInNV ";
Add support for "shaderRecordNV" qualifier
2019-06-03 13:25:21 +00:00
}
Emit storage qualifier in the correct place. Need to emit qualifiers in a specific order for legacy GLSL. <interpolation> <storage> <precision> <type>.
2017-02-24 08:56:17 +00:00
return "";
}
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
void CompilerGLSL::emit_flattened_io_block_member(const std::string &basename, const SPIRType &type, const char *qual,
const SmallVector<uint32_t> &indices)
{
GLSL: Support I/O flattening with arrays as final type.
2020-07-06 07:18:30 +00:00
uint32_t member_type_id = type.self;
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
const SPIRType *member_type = &type;
const SPIRType *parent_type = nullptr;
auto flattened_name = basename;
for (auto &index : indices)
{
flattened_name += "_";
flattened_name += to_member_name(*member_type, index);
parent_type = member_type;
GLSL: Support I/O flattening with arrays as final type.
2020-07-06 07:18:30 +00:00
member_type_id = member_type->member_types[index];
member_type = &get<SPIRType>(member_type_id);
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
}
assert(member_type->basetype != SPIRType::Struct);
Ensure that we use primary alias type when emitting flattened members.
2020-07-29 11:02:25 +00:00
// We're overriding struct member names, so ensure we do so on the primary type.
if (parent_type->type_alias)
parent_type = &get<SPIRType>(parent_type->type_alias);
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
// Sanitize underscores because joining the two identifiers might create more than 1 underscore in a row,
// which is not allowed.
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
ParsedIR::sanitize_underscores(flattened_name);
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
uint32_t last_index = indices.back();
// Pass in the varying qualifier here so it will appear in the correct declaration order.
// Replace member name while emitting it so it encodes both struct name and member name.
auto backup_name = get_member_name(parent_type->self, last_index);
auto member_name = to_member_name(*parent_type, last_index);
set_member_name(parent_type->self, last_index, flattened_name);
GLSL: Support I/O flattening with arrays as final type.
2020-07-06 07:18:30 +00:00
emit_struct_member(*parent_type, member_type_id, last_index, qual);
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
// Restore member name.
set_member_name(parent_type->self, last_index, member_name);
}
void CompilerGLSL::emit_flattened_io_block_struct(const std::string &basename, const SPIRType &type, const char *qual,
const SmallVector<uint32_t> &indices)
{
auto sub_indices = indices;
sub_indices.push_back(0);
const SPIRType *member_type = &type;
for (auto &index : indices)
member_type = &get<SPIRType>(member_type->member_types[index]);
assert(member_type->basetype == SPIRType::Struct);
GLSL: Support I/O flattening with arrays as final type.
2020-07-06 07:18:30 +00:00
if (!member_type->array.empty())
SPIRV_CROSS_THROW("Cannot flatten array of structs in I/O blocks.");
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
for (uint32_t i = 0; i < uint32_t(member_type->member_types.size()); i++)
{
sub_indices.back() = i;
if (get<SPIRType>(member_type->member_types[i]).basetype == SPIRType::Struct)
emit_flattened_io_block_struct(basename, type, qual, sub_indices);
else
emit_flattened_io_block_member(basename, type, qual, sub_indices);
}
}
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
void CompilerGLSL::emit_flattened_io_block(const SPIRVariable &var, const char *qual)
Emit storage qualifier in the correct place. Need to emit qualifiers in a specific order for legacy GLSL. <interpolation> <storage> <precision> <type>.
2017-02-24 08:56:17 +00:00
{
Ensure that we use primary alias type when emitting flattened members.
2020-07-29 11:02:25 +00:00
auto &var_type = get<SPIRType>(var.basetype);
if (!var_type.array.empty())
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
SPIRV_CROSS_THROW("Array of varying structs cannot be flattened to legacy-compatible varyings.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Ensure that we use primary alias type when emitting flattened members.
2020-07-29 11:02:25 +00:00
// Emit flattened types based on the type alias. Normally, we are never supposed to emit
// struct declarations for aliased types.
auto &type = var_type.type_alias ? get<SPIRType>(var_type.type_alias) : var_type;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto old_flags = ir.meta[type.self].decoration.decoration_flags;
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
// Emit the members as if they are part of a block to get all qualifiers.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
ir.meta[type.self].decoration.decoration_flags.set(DecorationBlock);
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
Clear member name cache in emit_flattened_io_block.
2017-11-22 10:19:54 +00:00
type.member_name_cache.clear();
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
SmallVector<uint32_t> member_indices;
member_indices.push_back(0);
auto basename = to_name(var.self);
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
uint32_t i = 0;
for (auto &member : type.member_types)
{
add_member_name(type, i);
auto &membertype = get<SPIRType>(member);
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
member_indices.back() = i;
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
if (membertype.basetype == SPIRType::Struct)
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
emit_flattened_io_block_struct(basename, type, qual, member_indices);
else
emit_flattened_io_block_member(basename, type, qual, member_indices);
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
i++;
}
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
ir.meta[type.self].decoration.decoration_flags = old_flags;
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
// Treat this variable as fully flattened from now on.
flattened_structs[var.self] = true;
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
void CompilerGLSL::emit_interface_block(const SPIRVariable &var)
{
auto &type = get<SPIRType>(var.basetype);
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
GLSL: Require GL_ARB_vertex_attrib_64bit for double input in pre-4.10
2020-11-12 21:59:28 +00:00
if (var.storage == StorageClassInput && type.basetype == SPIRType::Double &&
!options.es && options.version < 410)
{
require_extension_internal("GL_ARB_vertex_attrib_64bit");
}
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
// Either make it plain in/out or in/out blocks depending on what shader is doing ...
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
bool block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock);
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
const char *qual = to_storage_qualifiers_glsl(var);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
if (block)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
// ESSL earlier than 310 and GLSL earlier than 150 did not support
// I/O variables which are struct types.
// To support this, flatten the struct into separate varyings instead.
GLSL: Add option to force flattening IO blocks. It is not always desirable to use actual blocks. A prime example in the case where EXT_shader_io_blocks is not supported on the target implementation.
2020-07-28 13:15:24 +00:00
if (options.force_flattened_io_blocks || (options.es && options.version < 310) ||
(!options.es && options.version < 150))
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
{
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
// I/O blocks on ES require version 310 with Android Extension Pack extensions, or core version 320.
// On desktop, I/O blocks were introduced with geometry shaders in GL 3.2 (GLSL 150).
emit_flattened_io_block(var, qual);
}
else
{
if (options.es && options.version < 320)
{
// Geometry and tessellation extensions imply this extension.
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
if (!has_extension("GL_EXT_geometry_shader") && !has_extension("GL_EXT_tessellation_shader"))
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_EXT_shader_io_blocks");
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
}
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
// Workaround to make sure we can emit "patch in/out" correctly.
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
fixup_io_block_patch_primitive_qualifiers(var);
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
// Block names should never alias.
auto block_name = to_name(type.self, false);
GLSL: Allow blocks to have their own namespace.
2018-08-21 09:29:08 +00:00
// The namespace for I/O blocks is separate from other variables in GLSL.
auto &block_namespace = type.storage == StorageClassInput ? block_input_names : block_output_names;
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
// Shaders never use the block by interface name, so we don't
// have to track this other than updating name caches.
Get fallback name for block if name is empty.
2018-08-21 10:17:40 +00:00
if (block_name.empty() || block_namespace.find(block_name) != end(block_namespace))
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
block_name = get_fallback_name(type.self);
else
GLSL: Allow blocks to have their own namespace.
2018-08-21 09:29:08 +00:00
block_namespace.insert(block_name);
Get fallback name for block if name is empty.
2018-08-21 10:17:40 +00:00
// If for some reason buffer_name is an illegal name, make a final fallback to a workaround name.
// This cannot conflict with anything else, so we're safe now.
if (block_name.empty())
block_name = join("_", get<SPIRType>(var.basetype).self, "_", var.self);
GLSL: Allow blocks to have their own namespace.
2018-08-21 09:29:08 +00:00
// Instance names cannot alias block names.
resource_names.insert(block_name);
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
const char *block_qualifier;
if (has_decoration(var.self, DecorationPatch))
block_qualifier = "patch ";
else if (has_decoration(var.self, DecorationPerPrimitiveEXT))
block_qualifier = "perprimitiveEXT ";
HLSL: Implement SV_Barycentrics. Also fix perVertex on GLSL IO blocks.
2024-10-14 10:42:58 +00:00
else if (has_decoration(var.self, DecorationPerVertexKHR))
block_qualifier = "pervertexEXT ";
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
else
block_qualifier = "";
statement(layout_for_variable(var), block_qualifier, qual, block_name);
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
begin_scope();
type.member_name_cache.clear();
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
uint32_t i = 0;
for (auto &member : type.member_types)
{
add_member_name(type, i);
Updates to MSL functionality to support PR review feedback.
2017-03-11 17:17:22 +00:00
emit_struct_member(type, member, i);
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
i++;
}
Improve handling of block name declaration in GLSL. HLSL UAVs are a bit annoying because they can share block types, so reflection becomes rather awkward. Sometimes we will need to make some nasty fallbacks, so add a reflection interface which lets you query post-shader compile which names was actually declared in the shader.
2017-12-01 13:20:51 +00:00
add_resource_name(var.self);
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
end_scope_decl(join(to_name(var.self), type_to_array_glsl(type, var.self)));
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
statement("");
}
}
else
{
// ESSL earlier than 310 and GLSL earlier than 150 did not support
// I/O variables which are struct types.
// To support this, flatten the struct into separate varyings instead.
if (type.basetype == SPIRType::Struct &&
GLSL: Add option to force flattening IO blocks. It is not always desirable to use actual blocks. A prime example in the case where EXT_shader_io_blocks is not supported on the target implementation.
2020-07-28 13:15:24 +00:00
(options.force_flattened_io_blocks || (options.es && options.version < 310) ||
(!options.es && options.version < 150)))
Add support for flattening I/O blocks. Fix issue where layout() qualifiers are emitted for members in legacy targets.
2017-03-06 13:01:51 +00:00
{
emit_flattened_io_block(var, qual);
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
}
else
{
add_resource_name(var.self);
GLSL: Fix array of input patch variables. Hoist out the hack to make array sizes unsized to a place where we can differentiate patch variables from control point variables.
2019-12-10 11:00:55 +00:00
GLSL/HLSL: Add legacy handling for int vertex attributes
2023-01-14 17:56:54 +00:00
// Legacy GLSL did not support int attributes, we automatically
// declare them as float and cast them on load/store
SPIRType newtype = type;
if (is_legacy() && var.storage == StorageClassInput && type.basetype == SPIRType::Int)
newtype.basetype = SPIRType::Float;
// Tessellation control and evaluation shaders must have either
// gl_MaxPatchVertices or unsized arrays for input arrays.
GLSL: Fix array of input patch variables. Hoist out the hack to make array sizes unsized to a place where we can differentiate patch variables from control point variables.
2019-12-10 11:00:55 +00:00
// Opt for unsized as it's the more "correct" variant to use.
GLSL/HLSL: Add legacy handling for int vertex attributes
2023-01-14 17:56:54 +00:00
if (type.storage == StorageClassInput && !type.array.empty() &&
!has_decoration(var.self, DecorationPatch) &&
(get_entry_point().model == ExecutionModelTessellationControl ||
get_entry_point().model == ExecutionModelTessellationEvaluation))
GLSL: Fix array of input patch variables. Hoist out the hack to make array sizes unsized to a place where we can differentiate patch variables from control point variables.
2019-12-10 11:00:55 +00:00
{
GLSL/HLSL: Add legacy handling for int vertex attributes
2023-01-14 17:56:54 +00:00
newtype.array.back() = 0;
newtype.array_size_literal.back() = true;
GLSL: Fix array of input patch variables. Hoist out the hack to make array sizes unsized to a place where we can differentiate patch variables from control point variables.
2019-12-10 11:00:55 +00:00
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
statement(layout_for_variable(var), to_qualifiers_glsl(var.self),
GLSL/HLSL: Add legacy handling for int vertex attributes
2023-01-14 17:56:54 +00:00
variable_decl(newtype, to_name(var.self), var.self), ";");
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::emit_uniform(const SPIRVariable &var)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &type = get<SPIRType>(var.basetype);
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
if (type.basetype == SPIRType::Image && type.image.sampled == 2 && type.image.dim != DimSubpassData)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
if (!options.es && options.version < 420)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_shader_image_load_store");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (options.es && options.version < 310)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("At least ESSL 3.10 required for shader image load store.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
add_resource_name(var.self);
Emit storage qualifier in the correct place. Need to emit qualifiers in a specific order for legacy GLSL. <interpolation> <storage> <precision> <type>.
2017-02-24 08:56:17 +00:00
statement(layout_for_variable(var), variable_decl(var), ";");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
string CompilerGLSL::constant_value_macro_name(uint32_t id)
{
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
return join("SPIRV_CROSS_CONSTANT_ID_", id);
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
}
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
void CompilerGLSL::emit_specialization_constant_op(const SPIRConstantOp &constant)
{
auto &type = get<SPIRType>(constant.basetype);
GLSL: Ignore bogus constant/undefs which use block types. This is banned in more recent SPIR-V. We cannot implement this in any reasonable way since block types don't participate as normal types in GLSL.
2023-10-11 11:48:25 +00:00
// This will break. It is bogus and should not be legal.
if (type_is_top_level_block(type))
return;
Handle aliased names in spec constants. Need to register resource name.
2022-01-18 11:31:28 +00:00
add_resource_name(constant.self);
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
auto name = to_name(constant.self);
statement("const ", variable_decl(type, name), " = ", constant_op_expression(constant), ";");
}
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
int CompilerGLSL::get_constant_mapping_to_workgroup_component(const SPIRConstant &c) const
{
auto &entry_point = get_entry_point();
int index = -1;
// Need to redirect specialization constants which are used as WorkGroupSize to the builtin,
// since the spec constant declarations are never explicitly declared.
if (entry_point.workgroup_size.constant == 0 && entry_point.flags.get(ExecutionModeLocalSizeId))
{
if (c.self == entry_point.workgroup_size.id_x)
index = 0;
else if (c.self == entry_point.workgroup_size.id_y)
index = 1;
else if (c.self == entry_point.workgroup_size.id_z)
index = 2;
}
return index;
}
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
void CompilerGLSL::emit_constant(const SPIRConstant &constant)
Emit spec constants directly with Vulkan semantics. Emit an actual spec constant declaration in Vulkan instead of resolving the constant.
2016-10-03 10:52:56 +00:00
{
auto &type = get<SPIRType>(constant.constant_type);
GLSL: Ignore bogus constant/undefs which use block types. This is banned in more recent SPIR-V. We cannot implement this in any reasonable way since block types don't participate as normal types in GLSL.
2023-10-11 11:48:25 +00:00
// This will break. It is bogus and should not be legal.
if (type_is_top_level_block(type))
return;
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
SpecializationConstant wg_x, wg_y, wg_z;
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
ID workgroup_size_id = get_work_group_size_specialization_constants(wg_x, wg_y, wg_z);
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
// This specialization constant is implicitly declared by emitting layout() in;
if (constant.self == workgroup_size_id)
return;
// These specialization constants are implicitly declared by emitting layout() in;
// In legacy GLSL, we will still need to emit macros for these, so a layout() in; declaration
// later can use macro overrides for work group size.
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
bool is_workgroup_size_constant = ConstantID(constant.self) == wg_x.id || ConstantID(constant.self) == wg_y.id ||
ConstantID(constant.self) == wg_z.id;
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
if (options.vulkan_semantics && is_workgroup_size_constant)
{
// Vulkan GLSL does not need to declare workgroup spec constants explicitly, it is handled in layout().
return;
}
Run format_all.sh.
2018-11-01 10:23:33 +00:00
else if (!options.vulkan_semantics && is_workgroup_size_constant &&
!has_decoration(constant.self, DecorationSpecId))
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
{
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
// Only bother declaring a workgroup size if it is actually a specialization constant, because we need macros.
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
return;
}
Handle aliased names in spec constants. Need to register resource name.
2022-01-18 11:31:28 +00:00
add_resource_name(constant.self);
auto name = to_name(constant.self);
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
// Only scalars have constant IDs.
if (has_decoration(constant.self, DecorationSpecId))
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (options.vulkan_semantics)
{
statement("layout(constant_id = ", get_decoration(constant.self, DecorationSpecId), ") const ",
variable_decl(type, name), " = ", constant_expression(constant), ";");
}
else
{
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
const string &macro_name = constant.specialization_constant_macro_name;
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
statement("#ifndef ", macro_name);
statement("#define ", macro_name, " ", constant_expression(constant));
statement("#endif");
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
// For workgroup size constants, only emit the macros.
if (!is_workgroup_size_constant)
statement("const ", variable_decl(type, name), " = ", macro_name, ";");
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
}
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
}
else
{
statement("const ", variable_decl(type, name), " = ", constant_expression(constant), ";");
}
Emit spec constants directly with Vulkan semantics. Emit an actual spec constant declaration in Vulkan instead of resolving the constant.
2016-10-03 10:52:56 +00:00
}
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
void CompilerGLSL::emit_entry_point_declarations()
{
}
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
void CompilerGLSL::replace_illegal_names(const unordered_set<string> &keywords)
{
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, const SPIRVariable &var) {
if (is_hidden_variable(var))
return;
auto *meta = ir.find_meta(var.self);
if (!meta)
return;
auto &m = meta->decoration;
Handle reserved identifiers for functions. gl_ identifiers are already handled by fixups, so remove redundant code.
2021-01-04 08:59:26 +00:00
if (keywords.find(m.alias) != end(keywords))
m.alias = join("_", m.alias);
});
ir.for_each_typed_id<SPIRFunction>([&](uint32_t, const SPIRFunction &func) {
auto *meta = ir.find_meta(func.self);
if (!meta)
return;
auto &m = meta->decoration;
if (keywords.find(m.alias) != end(keywords))
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
m.alias = join("_", m.alias);
});
ir.for_each_typed_id<SPIRType>([&](uint32_t, const SPIRType &type) {
auto *meta = ir.find_meta(type.self);
if (!meta)
return;
auto &m = meta->decoration;
Handle reserved identifiers for functions. gl_ identifiers are already handled by fixups, so remove redundant code.
2021-01-04 08:59:26 +00:00
if (keywords.find(m.alias) != end(keywords))
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
m.alias = join("_", m.alias);
for (auto &memb : meta->members)
Handle reserved identifiers for functions. gl_ identifiers are already handled by fixups, so remove redundant code.
2021-01-04 08:59:26 +00:00
if (keywords.find(memb.alias) != end(keywords))
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
memb.alias = join("_", memb.alias);
});
}
Change variable names beginning with gl_ in GLSL Using old-school GLSL as input containing code ala "gl_FragColor = whatever" resulted in illegal declarations ala "out vec4 gl_FragColor;".
2016-08-12 22:14:52 +00:00
void CompilerGLSL::replace_illegal_names()
{
Fix style nits from last merge.
2016-10-27 11:55:47 +00:00
// clang-format off
static const unordered_set<string> keywords = {
Add builtin GLSL functions to blacklist.
2018-03-06 16:37:47 +00:00
"abs", "acos", "acosh", "all", "any", "asin", "asinh", "atan", "atanh",
"atomicAdd", "atomicCompSwap", "atomicCounter", "atomicCounterDecrement", "atomicCounterIncrement",
"atomicExchange", "atomicMax", "atomicMin", "atomicOr", "atomicXor",
"bitCount", "bitfieldExtract", "bitfieldInsert", "bitfieldReverse",
"ceil", "cos", "cosh", "cross", "degrees",
"dFdx", "dFdxCoarse", "dFdxFine",
"dFdy", "dFdyCoarse", "dFdyFine",
"distance", "dot", "EmitStreamVertex", "EmitVertex", "EndPrimitive", "EndStreamPrimitive", "equal", "exp", "exp2",
Support bitcasts of 16-bit types.
2018-11-05 20:55:56 +00:00
"faceforward", "findLSB", "findMSB", "float16BitsToInt16", "float16BitsToUint16", "floatBitsToInt", "floatBitsToUint", "floor", "fma", "fract",
"frexp", "fwidth", "fwidthCoarse", "fwidthFine",
Add builtin GLSL functions to blacklist.
2018-03-06 16:37:47 +00:00
"greaterThan", "greaterThanEqual", "groupMemoryBarrier",
"imageAtomicAdd", "imageAtomicAnd", "imageAtomicCompSwap", "imageAtomicExchange", "imageAtomicMax", "imageAtomicMin", "imageAtomicOr", "imageAtomicXor",
Support bitcasts of 16-bit types.
2018-11-05 20:55:56 +00:00
"imageLoad", "imageSamples", "imageSize", "imageStore", "imulExtended", "int16BitsToFloat16", "intBitsToFloat", "interpolateAtOffset", "interpolateAtCentroid", "interpolateAtSample",
Add builtin GLSL functions to blacklist.
2018-03-06 16:37:47 +00:00
"inverse", "inversesqrt", "isinf", "isnan", "ldexp", "length", "lessThan", "lessThanEqual", "log", "log2",
"matrixCompMult", "max", "memoryBarrier", "memoryBarrierAtomicCounter", "memoryBarrierBuffer", "memoryBarrierImage", "memoryBarrierShared",
"min", "mix", "mod", "modf", "noise", "noise1", "noise2", "noise3", "noise4", "normalize", "not", "notEqual",
Support bitcasts of 16-bit types.
2018-11-05 20:55:56 +00:00
"outerProduct", "packDouble2x32", "packHalf2x16", "packInt2x16", "packInt4x16", "packSnorm2x16", "packSnorm4x8",
"packUint2x16", "packUint4x16", "packUnorm2x16", "packUnorm4x8", "pow",
Add builtin GLSL functions to blacklist.
2018-03-06 16:37:47 +00:00
"radians", "reflect", "refract", "round", "roundEven", "sign", "sin", "sinh", "smoothstep", "sqrt", "step",
Don't limit GLSL identifiers with HLSL keywords. - The HLSL compiler now has its own list of keywords in addition to the ones from GLSL. - Added "buffer", "precise", and "shared" to the GLSL keywords.
2018-05-04 21:53:32 +00:00
"tan", "tanh", "texelFetch", "texelFetchOffset", "texture", "textureGather", "textureGatherOffset", "textureGatherOffsets",
Add builtin GLSL functions to blacklist.
2018-03-06 16:37:47 +00:00
"textureGrad", "textureGradOffset", "textureLod", "textureLodOffset", "textureOffset", "textureProj", "textureProjGrad",
"textureProjGradOffset", "textureProjLod", "textureProjLodOffset", "textureProjOffset", "textureQueryLevels", "textureQueryLod", "textureSamples", "textureSize",
Support bitcasts of 16-bit types.
2018-11-05 20:55:56 +00:00
"transpose", "trunc", "uaddCarry", "uint16BitsToFloat16", "uintBitsToFloat", "umulExtended", "unpackDouble2x32", "unpackHalf2x16", "unpackInt2x16", "unpackInt4x16",
"unpackSnorm2x16", "unpackSnorm4x8", "unpackUint2x16", "unpackUint4x16", "unpackUnorm2x16", "unpackUnorm4x8", "usubBorrow",
Add builtin GLSL functions to blacklist.
2018-03-06 16:37:47 +00:00
Don't limit GLSL identifiers with HLSL keywords. - The HLSL compiler now has its own list of keywords in addition to the ones from GLSL. - Added "buffer", "precise", and "shared" to the GLSL keywords.
2018-05-04 21:53:32 +00:00
"active", "asm", "atomic_uint", "attribute", "bool", "break", "buffer",
Add "texture" to the keyword list. I have encountered several shaders where people use "texture" as local variable (old shaders from times when it was not build-in).
2017-06-27 14:35:47 +00:00
"bvec2", "bvec3", "bvec4", "case", "cast", "centroid", "class", "coherent", "common", "const", "continue", "default", "discard",
"dmat2", "dmat2x2", "dmat2x3", "dmat2x4", "dmat3", "dmat3x2", "dmat3x3", "dmat3x4", "dmat4", "dmat4x2", "dmat4x3", "dmat4x4",
"do", "double", "dvec2", "dvec3", "dvec4", "else", "enum", "extern", "external", "false", "filter", "fixed", "flat", "float",
"for", "fvec2", "fvec3", "fvec4", "goto", "half", "highp", "hvec2", "hvec3", "hvec4", "if", "iimage1D", "iimage1DArray",
"iimage2D", "iimage2DArray", "iimage2DMS", "iimage2DMSArray", "iimage2DRect", "iimage3D", "iimageBuffer", "iimageCube",
"iimageCubeArray", "image1D", "image1DArray", "image2D", "image2DArray", "image2DMS", "image2DMSArray", "image2DRect",
"image3D", "imageBuffer", "imageCube", "imageCubeArray", "in", "inline", "inout", "input", "int", "interface", "invariant",
"isampler1D", "isampler1DArray", "isampler2D", "isampler2DArray", "isampler2DMS", "isampler2DMSArray", "isampler2DRect",
Don't limit GLSL identifiers with HLSL keywords. - The HLSL compiler now has its own list of keywords in addition to the ones from GLSL. - Added "buffer", "precise", and "shared" to the GLSL keywords.
2018-05-04 21:53:32 +00:00
"isampler3D", "isamplerBuffer", "isamplerCube", "isamplerCubeArray", "ivec2", "ivec3", "ivec4", "layout", "long", "lowp",
"mat2", "mat2x2", "mat2x3", "mat2x4", "mat3", "mat3x2", "mat3x3", "mat3x4", "mat4", "mat4x2", "mat4x3", "mat4x4", "mediump",
"namespace", "noinline", "noperspective", "out", "output", "packed", "partition", "patch", "precise", "precision", "public", "readonly",
"resource", "restrict", "return", "sample", "sampler1D", "sampler1DArray", "sampler1DArrayShadow",
Add "texture" to the keyword list. I have encountered several shaders where people use "texture" as local variable (old shaders from times when it was not build-in).
2017-06-27 14:35:47 +00:00
"sampler1DShadow", "sampler2D", "sampler2DArray", "sampler2DArrayShadow", "sampler2DMS", "sampler2DMSArray",
"sampler2DRect", "sampler2DRectShadow", "sampler2DShadow", "sampler3D", "sampler3DRect", "samplerBuffer",
Don't limit GLSL identifiers with HLSL keywords. - The HLSL compiler now has its own list of keywords in addition to the ones from GLSL. - Added "buffer", "precise", and "shared" to the GLSL keywords.
2018-05-04 21:53:32 +00:00
"samplerCube", "samplerCubeArray", "samplerCubeArrayShadow", "samplerCubeShadow", "shared", "short", "sizeof", "smooth", "static",
Add "texture" to the keyword list. I have encountered several shaders where people use "texture" as local variable (old shaders from times when it was not build-in).
2017-06-27 14:35:47 +00:00
"struct", "subroutine", "superp", "switch", "template", "this", "true", "typedef", "uimage1D", "uimage1DArray", "uimage2D",
"uimage2DArray", "uimage2DMS", "uimage2DMSArray", "uimage2DRect", "uimage3D", "uimageBuffer", "uimageCube",
"uimageCubeArray", "uint", "uniform", "union", "unsigned", "usampler1D", "usampler1DArray", "usampler2D", "usampler2DArray",
"usampler2DMS", "usampler2DMSArray", "usampler2DRect", "usampler3D", "usamplerBuffer", "usamplerCube",
Don't limit GLSL identifiers with HLSL keywords. - The HLSL compiler now has its own list of keywords in addition to the ones from GLSL. - Added "buffer", "precise", and "shared" to the GLSL keywords.
2018-05-04 21:53:32 +00:00
"usamplerCubeArray", "using", "uvec2", "uvec3", "uvec4", "varying", "vec2", "vec3", "vec4", "void", "volatile",
"while", "writeonly",
Fix style nits from last merge.
2016-10-27 11:55:47 +00:00
};
// clang-format on
Added all glsl reserved keywords to replace_illegal_names
2016-10-27 10:51:22 +00:00
Deal with illegal names in types as well. - Fixes issue with clip_distance flattening in MSL where member to flatten from would come from to_member_name, where it should have used the builtin name directly. This member name was modified by this patch and broke clip distance test shaders. - Some cleanups with ir.meta, use ir.find_meta instead to not create unnecessary hashmap nodes.
2020-01-16 09:28:54 +00:00
replace_illegal_names(keywords);
Change variable names beginning with gl_ in GLSL Using old-school GLSL as input containing code ala "gl_FragColor = whatever" resulted in illegal declarations ala "out vec4 gl_FragColor;".
2016-08-12 22:14:52 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::replace_fragment_output(SPIRVariable &var)
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &m = ir.meta[var.self].decoration;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t location = 0;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (m.decoration_flags.get(DecorationLocation))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
location = m.location;
Initial commit.
2016-03-02 17:09:16 +00:00
Fix legacy GLSL output with gl_FragData. If the source GLSL file accessed gl_FragData, we got double up with array access, giving invalid GLSL.
2016-08-18 10:55:19 +00:00
// If our variable is arrayed, we must not emit the array part of this as the SPIR-V will
// do the access chain part of this for us.
auto &type = get<SPIRType>(var.basetype);
if (type.array.empty())
{
// Redirect the write to a specific render target in legacy GLSL.
m.alias = join("gl_FragData[", location, "]");
Clean up.
2016-09-17 13:56:23 +00:00
if (is_legacy_es() && location != 0)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_EXT_draw_buffers");
Fix legacy GLSL output with gl_FragData. If the source GLSL file accessed gl_FragData, we got double up with array access, giving invalid GLSL.
2016-08-18 10:55:19 +00:00
}
else if (type.array.size() == 1)
{
// If location is non-zero, we probably have to add an offset.
// This gets really tricky since we'd have to inject an offset in the access chain.
// FIXME: This seems like an extremely odd-ball case, so it's probably fine to leave it like this for now.
m.alias = "gl_FragData";
if (location != 0)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Arrayed output variable used, but location is not 0. "
"This is unimplemented in SPIRV-Cross.");
Run format.sh.
2016-09-17 16:46:10 +00:00
Legacy GLES extensions.
2016-09-17 12:33:16 +00:00
if (is_legacy_es())
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_EXT_draw_buffers");
Fix legacy GLSL output with gl_FragData. If the source GLSL file accessed gl_FragData, we got double up with array access, giving invalid GLSL.
2016-08-18 10:55:19 +00:00
}
else
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Array-of-array output variable used. This cannot be implemented in legacy GLSL.");
Fix legacy GLSL output with gl_FragData. If the source GLSL file accessed gl_FragData, we got double up with array access, giving invalid GLSL.
2016-08-18 10:55:19 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
var.compat_builtin = true; // We don't want to declare this variable, but use the name as-is.
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::replace_fragment_outputs()
{
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(var.basetype);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Run format_all.sh.
2019-01-11 11:56:00 +00:00
if (!is_builtin_variable(var) && !var.remapped_variable && type.pointer && var.storage == StorageClassOutput)
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
replace_fragment_output(var);
});
Initial commit.
2016-03-02 17:09:16 +00:00
}
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
string CompilerGLSL::remap_swizzle(const SPIRType &out_type, uint32_t input_components, const string &expr)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (out_type.vecsize == input_components)
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
return expr;
Fix compatibility with FXC.
2017-12-12 10:03:46 +00:00
else if (input_components == 1 && !backend.can_swizzle_scalar)
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
return join(type_to_glsl(out_type), "(", expr, ")");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
{
Deal with packed expressions in more scenarios. Make a new "to_extract_component_expression" helper.
2018-05-25 08:56:27 +00:00
// FIXME: This will not work with packed expressions.
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
auto e = enclose_expression(expr) + ".";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Just clamp the swizzle index if we have more outputs than inputs.
for (uint32_t c = 0; c < out_type.vecsize; c++)
e += index_to_swizzle(min(c, input_components - 1));
if (backend.swizzle_is_function && out_type.vecsize > 1)
e += "()";
Remove duplicate swizzles in remap_swizzle. Makes HLSL image-load-store look much nicer.
2017-12-12 12:01:10 +00:00
remove_duplicate_swizzle(e);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return e;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::emit_pls()
{
Add support for multiple entry points. - Only consider I/O variables if part of OpEntryPoint. - Keep a safe fallback if #entry-points is 1 to avoid potentially breaking previously working shaders.
2016-07-28 09:16:02 +00:00
auto &execution = get_entry_point();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (execution.model != ExecutionModelFragment)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Pixel local storage only supported in fragment shaders.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!options.es)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Pixel local storage only supported in OpenGL ES.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (options.version < 300)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Pixel local storage only supported in ESSL 3.0 and above.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!pls_inputs.empty())
{
statement("__pixel_local_inEXT _PLSIn");
begin_scope();
for (auto &input : pls_inputs)
statement(pls_decl(input), ";");
end_scope_decl();
statement("");
}
if (!pls_outputs.empty())
{
statement("__pixel_local_outEXT _PLSOut");
begin_scope();
for (auto &output : pls_outputs)
statement(pls_decl(output), ";");
end_scope_decl();
statement("");
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Fix handling of NoWrite/NoRead decoration for images. The old workaround for glslang is no longer needed, so only apply workaround carefully.
2017-01-05 17:16:33 +00:00
void CompilerGLSL::fixup_image_load_store_access()
{
Add option to disable storage image qualifier deduction.
2020-03-04 15:15:01 +00:00
if (!options.enable_storage_image_qualifier_deduction)
return;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t var, const SPIRVariable &) {
Fix handling of NoWrite/NoRead decoration for images. The old workaround for glslang is no longer needed, so only apply workaround carefully.
2017-01-05 17:16:33 +00:00
auto &vartype = expression_type(var);
Do not add NonWritable/NonReadable decorations for regular images.
2020-04-03 10:26:13 +00:00
if (vartype.basetype == SPIRType::Image && vartype.image.sampled == 2)
Fix handling of NoWrite/NoRead decoration for images. The old workaround for glslang is no longer needed, so only apply workaround carefully.
2017-01-05 17:16:33 +00:00
{
Add option to disable storage image qualifier deduction.
2020-03-04 15:15:01 +00:00
// Very old glslangValidator and HLSL compilers do not emit required qualifiers here.
Fix handling of NoWrite/NoRead decoration for images. The old workaround for glslang is no longer needed, so only apply workaround carefully.
2017-01-05 17:16:33 +00:00
// Solve this by making the image access as restricted as possible and loosen up if we need to.
// If any no-read/no-write flags are actually set, assume that the compiler knows what it's doing.
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
if (!has_decoration(var, DecorationNonWritable) && !has_decoration(var, DecorationNonReadable))
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
{
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
set_decoration(var, DecorationNonWritable);
set_decoration(var, DecorationNonReadable);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
}
Fix handling of NoWrite/NoRead decoration for images. The old workaround for glslang is no longer needed, so only apply workaround carefully.
2017-01-05 17:16:33 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Fix handling of NoWrite/NoRead decoration for images. The old workaround for glslang is no longer needed, so only apply workaround carefully.
2017-01-05 17:16:33 +00:00
}
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
static bool is_block_builtin(BuiltIn builtin)
{
return builtin == BuiltInPosition || builtin == BuiltInPointSize || builtin == BuiltInClipDistance ||
builtin == BuiltInCullDistance;
}
bool CompilerGLSL::should_force_emit_builtin_block(StorageClass storage)
{
// If the builtin block uses XFB, we need to force explicit redeclaration of the builtin block.
if (storage != StorageClassOutput)
return false;
bool should_force = false;
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
if (should_force)
return;
auto &type = this->get<SPIRType>(var.basetype);
bool block = has_decoration(type.self, DecorationBlock);
if (var.storage == storage && block && is_builtin_variable(var))
{
uint32_t member_count = uint32_t(type.member_types.size());
for (uint32_t i = 0; i < member_count; i++)
{
if (has_member_decoration(type.self, i, DecorationBuiltIn) &&
is_block_builtin(BuiltIn(get_member_decoration(type.self, i, DecorationBuiltIn))) &&
has_member_decoration(type.self, i, DecorationOffset))
{
should_force = true;
}
}
}
else if (var.storage == storage && !block && is_builtin_variable(var))
{
if (is_block_builtin(BuiltIn(get_decoration(type.self, DecorationBuiltIn))) &&
has_decoration(var.self, DecorationOffset))
{
should_force = true;
}
}
});
GLSL: Force block declaration if clip/cull is used in tesc.
2021-01-07 11:14:49 +00:00
// If we're declaring clip/cull planes with control points we need to force block declaration.
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if ((get_execution_model() == ExecutionModelTessellationControl ||
get_execution_model() == ExecutionModelMeshEXT) &&
GLSL: Force block declaration if clip/cull is used in tesc.
2021-01-07 11:14:49 +00:00
(clip_distance_count || cull_distance_count))
{
should_force = true;
}
GLSL: Emit inline invariant position for mesh shaders. Work around missing feature from GLSL. Normally we can emit a global invariant gl_Position; and call it a day, but it does not work for mesh shaders it seems. Declaring invariance inside an explicit IO block works fine on the other hand ...
2023-08-17 10:36:21 +00:00
// Either glslang bug or oversight, but global invariant position does not work in mesh shaders.
if (get_execution_model() == ExecutionModelMeshEXT && position_invariant)
should_force = true;
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
return should_force;
}
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
void CompilerGLSL::fixup_implicit_builtin_block_names(ExecutionModel model)
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
{
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
auto &type = this->get<SPIRType>(var.basetype);
bool block = has_decoration(type.self, DecorationBlock);
if ((var.storage == StorageClassOutput || var.storage == StorageClassInput) && block &&
is_builtin_variable(var))
{
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if (model != ExecutionModelMeshEXT)
{
// Make sure the array has a supported name in the code.
if (var.storage == StorageClassOutput)
set_name(var.self, "gl_out");
else if (var.storage == StorageClassInput)
set_name(var.self, "gl_in");
}
else
{
auto flags = get_buffer_block_flags(var.self);
if (flags.get(DecorationPerPrimitiveEXT))
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
{
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
set_name(var.self, "gl_MeshPrimitivesEXT");
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
set_name(type.self, "gl_MeshPerPrimitiveEXT");
}
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
else
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
{
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
set_name(var.self, "gl_MeshVerticesEXT");
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
set_name(type.self, "gl_MeshPerVertexEXT");
}
}
}
if (model == ExecutionModelMeshEXT && var.storage == StorageClassOutput && !block)
{
auto *m = ir.find_meta(var.self);
HLSL: Fix-up some style issues from review.
2022-11-02 11:13:42 +00:00
if (m && m->decoration.builtin)
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
{
HLSL: Fix-up some style issues from review.
2022-11-02 11:13:42 +00:00
auto builtin_type = m->decoration.builtin_type;
if (builtin_type == BuiltInPrimitivePointIndicesEXT)
set_name(var.self, "gl_PrimitivePointIndicesEXT");
else if (builtin_type == BuiltInPrimitiveLineIndicesEXT)
set_name(var.self, "gl_PrimitiveLineIndicesEXT");
else if (builtin_type == BuiltInPrimitiveTriangleIndicesEXT)
set_name(var.self, "gl_PrimitiveTriangleIndicesEXT");
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
}
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
}
});
}
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
void CompilerGLSL::emit_declared_builtin_block(StorageClass storage, ExecutionModel model)
{
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
Bitset emitted_builtins;
Bitset global_builtins;
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
const SPIRVariable *block_var = nullptr;
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
bool emitted_block = false;
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
// Need to use declared size in the type.
// These variables might have been declared, but not statically used, so we haven't deduced their size yet.
uint32_t cull_distance_size = 0;
uint32_t clip_distance_size = 0;
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
bool have_xfb_buffer_stride = false;
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
bool have_geom_stream = false;
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
bool have_any_xfb_offset = false;
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
uint32_t xfb_stride = 0, xfb_buffer = 0, geom_stream = 0;
Compile fix on older compilers.
2020-01-27 14:56:47 +00:00
std::unordered_map<uint32_t, uint32_t> builtin_xfb_offsets;
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
const auto builtin_is_per_vertex_set = [](BuiltIn builtin) -> bool {
return builtin == BuiltInPosition || builtin == BuiltInPointSize ||
builtin == BuiltInClipDistance || builtin == BuiltInCullDistance;
};
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(var.basetype);
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
bool block = has_decoration(type.self, DecorationBlock);
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
Bitset builtins;
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
if (var.storage == storage && block && is_builtin_variable(var))
{
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
uint32_t index = 0;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
for (auto &m : ir.meta[type.self].members)
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
{
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if (m.builtin && builtin_is_per_vertex_set(m.builtin_type))
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
{
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
builtins.set(m.builtin_type);
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
if (m.builtin_type == BuiltInCullDistance)
GLSL: Use literal array size for cull/clip array sizes.
2020-09-30 11:01:18 +00:00
cull_distance_size = to_array_size_literal(this->get<SPIRType>(type.member_types[index]));
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
else if (m.builtin_type == BuiltInClipDistance)
GLSL: Use literal array size for cull/clip array sizes.
2020-09-30 11:01:18 +00:00
clip_distance_size = to_array_size_literal(this->get<SPIRType>(type.member_types[index]));
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
if (is_block_builtin(m.builtin_type) && m.decoration_flags.get(DecorationOffset))
{
have_any_xfb_offset = true;
builtin_xfb_offsets[m.builtin_type] = m.offset;
}
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
if (is_block_builtin(m.builtin_type) && m.decoration_flags.get(DecorationStream))
{
uint32_t stream = m.stream;
if (have_geom_stream && geom_stream != stream)
SPIRV_CROSS_THROW("IO block member Stream mismatch.");
have_geom_stream = true;
geom_stream = stream;
}
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
}
index++;
}
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
if (storage == StorageClassOutput && has_decoration(var.self, DecorationXfbBuffer) &&
has_decoration(var.self, DecorationXfbStride))
{
uint32_t buffer_index = get_decoration(var.self, DecorationXfbBuffer);
uint32_t stride = get_decoration(var.self, DecorationXfbStride);
if (have_xfb_buffer_stride && buffer_index != xfb_buffer)
SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch.");
if (have_xfb_buffer_stride && stride != xfb_stride)
SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch.");
have_xfb_buffer_stride = true;
xfb_buffer = buffer_index;
xfb_stride = stride;
}
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
if (storage == StorageClassOutput && has_decoration(var.self, DecorationStream))
{
uint32_t stream = get_decoration(var.self, DecorationStream);
if (have_geom_stream && geom_stream != stream)
SPIRV_CROSS_THROW("IO block member Stream mismatch.");
have_geom_stream = true;
geom_stream = stream;
}
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
}
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
else if (var.storage == storage && !block && is_builtin_variable(var))
{
// While we're at it, collect all declared global builtins (HLSL mostly ...).
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &m = ir.meta[var.self].decoration;
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if (m.builtin && builtin_is_per_vertex_set(m.builtin_type))
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
{
GLSL: Fix Clip/Cull in mesh shaders.
2023-08-25 09:50:19 +00:00
// For mesh/tesc output, Clip/Cull is an array-of-array. Look at innermost array type
// for correct result.
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
global_builtins.set(m.builtin_type);
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
if (m.builtin_type == BuiltInCullDistance)
GLSL: Fix Clip/Cull in mesh shaders.
2023-08-25 09:50:19 +00:00
cull_distance_size = to_array_size_literal(type, 0);
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
else if (m.builtin_type == BuiltInClipDistance)
GLSL: Fix Clip/Cull in mesh shaders.
2023-08-25 09:50:19 +00:00
clip_distance_size = to_array_size_literal(type, 0);
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
if (is_block_builtin(m.builtin_type) && m.decoration_flags.get(DecorationXfbStride) &&
m.decoration_flags.get(DecorationXfbBuffer) && m.decoration_flags.get(DecorationOffset))
{
have_any_xfb_offset = true;
builtin_xfb_offsets[m.builtin_type] = m.offset;
uint32_t buffer_index = m.xfb_buffer;
uint32_t stride = m.xfb_stride;
if (have_xfb_buffer_stride && buffer_index != xfb_buffer)
SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch.");
if (have_xfb_buffer_stride && stride != xfb_stride)
SPIRV_CROSS_THROW("IO block member XfbBuffer mismatch.");
have_xfb_buffer_stride = true;
xfb_buffer = buffer_index;
xfb_stride = stride;
}
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
if (is_block_builtin(m.builtin_type) && m.decoration_flags.get(DecorationStream))
{
uint32_t stream = get_decoration(var.self, DecorationStream);
if (have_geom_stream && geom_stream != stream)
SPIRV_CROSS_THROW("IO block member Stream mismatch.");
have_geom_stream = true;
geom_stream = stream;
}
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
}
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
}
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
if (builtins.empty())
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
return;
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
if (emitted_block)
SPIRV_CROSS_THROW("Cannot use more than one builtin I/O block.");
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
emitted_builtins = builtins;
emitted_block = true;
block_var = &var;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
Run format_all.sh.
2018-03-13 13:05:33 +00:00
global_builtins =
Bitset(global_builtins.get_lower() & ((1ull << BuiltInPosition) | (1ull << BuiltInPointSize) |
(1ull << BuiltInClipDistance) | (1ull << BuiltInCullDistance)));
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
// Try to collect all other declared builtins.
if (!emitted_block)
emitted_builtins = global_builtins;
// Can't declare an empty interface block.
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
if (emitted_builtins.empty())
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
return;
if (storage == StorageClassOutput)
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
{
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
SmallVector<string> attr;
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
if (have_xfb_buffer_stride && have_any_xfb_offset)
{
if (!options.es)
{
if (options.version < 440 && options.version >= 140)
require_extension_internal("GL_ARB_enhanced_layouts");
else if (options.version < 140)
SPIRV_CROSS_THROW("Component decoration is not supported in targets below GLSL 1.40.");
if (!options.es && options.version < 440)
require_extension_internal("GL_ARB_enhanced_layouts");
}
else if (options.es)
SPIRV_CROSS_THROW("Need GL_ARB_enhanced_layouts for xfb_stride or xfb_buffer.");
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
attr.push_back(join("xfb_buffer = ", xfb_buffer, ", xfb_stride = ", xfb_stride));
}
if (have_geom_stream)
{
if (get_execution_model() != ExecutionModelGeometry)
SPIRV_CROSS_THROW("Geometry streams can only be used in geometry shaders.");
if (options.es)
SPIRV_CROSS_THROW("Multiple geometry streams not supported in ESSL.");
if (options.version < 400)
require_extension_internal("GL_ARB_transform_feedback3");
attr.push_back(join("stream = ", geom_stream));
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
}
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if (model == ExecutionModelMeshEXT)
statement("out gl_MeshPerVertexEXT");
else if (!attr.empty())
GLSL: Add support for transform_feedback3 geometry streams.
2020-09-30 11:01:35 +00:00
statement("layout(", merge(attr), ") out gl_PerVertex");
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
else
statement("out gl_PerVertex");
}
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
else
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
{
// If we have passthrough, there is no way PerVertex cannot be passthrough.
if (get_entry_point().geometry_passthrough)
statement("layout(passthrough) in gl_PerVertex");
else
statement("in gl_PerVertex");
}
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
begin_scope();
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
if (emitted_builtins.get(BuiltInPosition))
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
{
auto itr = builtin_xfb_offsets.find(BuiltInPosition);
if (itr != end(builtin_xfb_offsets))
statement("layout(xfb_offset = ", itr->second, ") vec4 gl_Position;");
GLSL: Emit inline invariant position for mesh shaders. Work around missing feature from GLSL. Normally we can emit a global invariant gl_Position; and call it a day, but it does not work for mesh shaders it seems. Declaring invariance inside an explicit IO block works fine on the other hand ...
2023-08-17 10:36:21 +00:00
else if (position_invariant)
statement("invariant vec4 gl_Position;");
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
else
statement("vec4 gl_Position;");
}
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
if (emitted_builtins.get(BuiltInPointSize))
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
{
auto itr = builtin_xfb_offsets.find(BuiltInPointSize);
if (itr != end(builtin_xfb_offsets))
statement("layout(xfb_offset = ", itr->second, ") float gl_PointSize;");
else
statement("float gl_PointSize;");
}
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
if (emitted_builtins.get(BuiltInClipDistance))
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
{
auto itr = builtin_xfb_offsets.find(BuiltInClipDistance);
if (itr != end(builtin_xfb_offsets))
statement("layout(xfb_offset = ", itr->second, ") float gl_ClipDistance[", clip_distance_size, "];");
else
statement("float gl_ClipDistance[", clip_distance_size, "];");
}
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
if (emitted_builtins.get(BuiltInCullDistance))
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
{
auto itr = builtin_xfb_offsets.find(BuiltInCullDistance);
if (itr != end(builtin_xfb_offsets))
statement("layout(xfb_offset = ", itr->second, ") float gl_CullDistance[", cull_distance_size, "];");
else
statement("float gl_CullDistance[", cull_distance_size, "];");
}
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
GLSL: Declare gl_in/gl_out as array more robustly. If a builtin block was not already declared, we would miss some scenarios.
2023-01-12 15:05:17 +00:00
bool builtin_array = model == ExecutionModelTessellationControl ||
(model == ExecutionModelMeshEXT && storage == StorageClassOutput) ||
(model == ExecutionModelGeometry && storage == StorageClassInput) ||
(model == ExecutionModelTessellationEvaluation && storage == StorageClassInput);
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
if (builtin_array)
{
GLSL: Declare gl_in/gl_out as array more robustly. If a builtin block was not already declared, we would miss some scenarios.
2023-01-12 15:05:17 +00:00
const char *instance_name;
if (model == ExecutionModelMeshEXT)
instance_name = "gl_MeshVerticesEXT"; // Per primitive is never synthesized.
else
instance_name = storage == StorageClassInput ? "gl_in" : "gl_out";
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
if (model == ExecutionModelTessellationControl && storage == StorageClassOutput)
GLSL: Declare gl_in/gl_out as array more robustly. If a builtin block was not already declared, we would miss some scenarios.
2023-01-12 15:05:17 +00:00
end_scope_decl(join(instance_name, "[", get_entry_point().output_vertices, "]"));
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
else
GLSL: Declare gl_in/gl_out as array more robustly. If a builtin block was not already declared, we would miss some scenarios.
2023-01-12 15:05:17 +00:00
end_scope_decl(join(instance_name, "[]"));
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
}
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
else
end_scope_decl();
statement("");
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
}
Support LUTs in single-function CFGs on Private storage class. Fairly common pattern in unoptimized SPIR-V. Support this case as well.
2019-02-06 09:38:18 +00:00
bool CompilerGLSL::variable_is_lut(const SPIRVariable &var) const
{
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
bool statically_assigned = var.statically_assigned && var.static_expression != ID(0) && var.remapped_variable;
Support LUTs in single-function CFGs on Private storage class. Fairly common pattern in unoptimized SPIR-V. Support this case as well.
2019-02-06 09:38:18 +00:00
if (statically_assigned)
{
auto *constant = maybe_get<SPIRConstant>(var.static_expression);
if (constant && constant->is_used_as_lut)
return true;
}
return false;
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::emit_resources()
{
Add support for multiple entry points. - Only consider I/O variables if part of OpEntryPoint. - Keep a safe fallback if #entry-points is 1 to avoid potentially breaking previously working shaders.
2016-07-28 09:16:02 +00:00
auto &execution = get_entry_point();
Change variable names beginning with gl_ in GLSL Using old-school GLSL as input containing code ala "gl_FragColor = whatever" resulted in illegal declarations ala "out vec4 gl_FragColor;".
2016-08-12 22:14:52 +00:00
replace_illegal_names();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Legacy GL uses gl_FragData[], redeclare all fragment outputs
// with builtins.
if (execution.model == ExecutionModelFragment && is_legacy())
replace_fragment_outputs();
// Emit PLS blocks if we have such variables.
if (!pls_inputs.empty() || !pls_outputs.empty())
emit_pls();
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
switch (execution.model)
{
case ExecutionModelGeometry:
case ExecutionModelTessellationControl:
case ExecutionModelTessellationEvaluation:
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
case ExecutionModelMeshEXT:
fixup_implicit_builtin_block_names(execution.model);
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
break;
default:
break;
}
GLSL: Emit inline invariant position for mesh shaders. Work around missing feature from GLSL. Normally we can emit a global invariant gl_Position; and call it a day, but it does not work for mesh shaders it seems. Declaring invariance inside an explicit IO block works fine on the other hand ...
2023-08-17 10:36:21 +00:00
bool global_invariant_position = position_invariant && (options.es || options.version >= 120);
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
// Emit custom gl_PerVertex for SSO compatibility.
Overhaul clip/cull distance support in GLSL.
2018-02-22 13:36:50 +00:00
if (options.separate_shader_objects && !options.es && execution.model != ExecutionModelFragment)
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
{
switch (execution.model)
{
case ExecutionModelGeometry:
case ExecutionModelTessellationControl:
case ExecutionModelTessellationEvaluation:
emit_declared_builtin_block(StorageClassInput, execution.model);
emit_declared_builtin_block(StorageClassOutput, execution.model);
GLSL: Emit inline invariant position for mesh shaders. Work around missing feature from GLSL. Normally we can emit a global invariant gl_Position; and call it a day, but it does not work for mesh shaders it seems. Declaring invariance inside an explicit IO block works fine on the other hand ...
2023-08-17 10:36:21 +00:00
global_invariant_position = false;
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
break;
case ExecutionModelVertex:
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
case ExecutionModelMeshEXT:
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
emit_declared_builtin_block(StorageClassOutput, execution.model);
GLSL: Emit inline invariant position for mesh shaders. Work around missing feature from GLSL. Normally we can emit a global invariant gl_Position; and call it a day, but it does not work for mesh shaders it seems. Declaring invariance inside an explicit IO block works fine on the other hand ...
2023-08-17 10:36:21 +00:00
global_invariant_position = false;
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
break;
default:
break;
}
}
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
else if (should_force_emit_builtin_block(StorageClassOutput))
{
emit_declared_builtin_block(StorageClassOutput, execution.model);
GLSL: Emit inline invariant position for mesh shaders. Work around missing feature from GLSL. Normally we can emit a global invariant gl_Position; and call it a day, but it does not work for mesh shaders it seems. Declaring invariance inside an explicit IO block works fine on the other hand ...
2023-08-17 10:36:21 +00:00
global_invariant_position = false;
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
}
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
else if (execution.geometry_passthrough)
{
// Need to declare gl_in with Passthrough.
GLSL: Support GL_ARB_enchanced_layouts for XFB.
2020-01-27 11:56:48 +00:00
// If we're doing passthrough, we cannot emit an output block, so the output block test above will never pass.
GLSL: Implement geometry shader passthrough extension.
2020-01-15 15:18:29 +00:00
emit_declared_builtin_block(StorageClassInput, execution.model);
}
Overhaul clip/cull distance support in GLSL.
2018-02-22 13:36:50 +00:00
else
{
// Need to redeclare clip/cull distance with explicit size to use them.
// SPIR-V mandates these builtins have a size declared.
const char *storage = execution.model == ExecutionModelFragment ? "in" : "out";
if (clip_distance_count != 0)
statement(storage, " float gl_ClipDistance[", clip_distance_count, "];");
if (cull_distance_count != 0)
statement(storage, " float gl_CullDistance[", cull_distance_count, "];");
if (clip_distance_count != 0 || cull_distance_count != 0)
statement("");
}
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
GLSL: Emit inline invariant position for mesh shaders. Work around missing feature from GLSL. Normally we can emit a global invariant gl_Position; and call it a day, but it does not work for mesh shaders it seems. Declaring invariance inside an explicit IO block works fine on the other hand ...
2023-08-17 10:36:21 +00:00
if (global_invariant_position)
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
{
statement("invariant gl_Position;");
statement("");
}
Support arrays which have spec constant size. The size of an array can be a specialization constant or a spec constant op. This complicates things quite a lot. Reflection becomes very painful in the presence of expressions instead of literals so add a new array which expresses this. It is unlikely that we will need to do accurate reflection of interface types which have specialization constant size. SSBOs and UBOs will for now throw exception if a dynamic size is used since it is very difficult to know the real size.
2016-10-03 15:17:11 +00:00
bool emitted = false;
// If emitted Vulkan GLSL,
// emit specialization constants as actual floats,
// spec op expressions will redirect to the constant name.
//
{
Start considering how to emit physical type ID.
2019-07-18 15:05:28 +00:00
auto loop_lock = ir.create_loop_hard_lock();
Interleave undef values with constants and types. Undef values may be of struct type and may be used in constants. Therefore, they must be interleaved with constants and types. Fixes the rest of the Vulkan CTS test `dEQP-VK.spirv_assembly.instruction.compute.opundef.undefined_spec_constant_composite`. (Please excuse the churn in the reference output; it's an inevitable result of this change.)
2022-11-09 04:04:36 +00:00
for (auto &id_ : ir.ids_for_constant_undef_or_type)
Support arrays which have spec constant size. The size of an array can be a specialization constant or a spec constant op. This complicates things quite a lot. Reflection becomes very painful in the presence of expressions instead of literals so add a new array which expresses this. It is unlikely that we will need to do accurate reflection of interface types which have specialization constant size. SSBOs and UBOs will for now throw exception if a dynamic size is used since it is very difficult to know the real size.
2016-10-03 15:17:11 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
auto &id = ir.ids[id_];
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
GLSL: Ignore bogus constant/undefs which use block types. This is banned in more recent SPIR-V. We cannot implement this in any reasonable way since block types don't participate as normal types in GLSL.
2023-10-11 11:48:25 +00:00
// Skip declaring any bogus constants or undefs which use block types.
// We don't declare block types directly, so this will never work.
// Should not be legal SPIR-V, so this is considered a workaround.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (id.get_type() == TypeConstant)
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
auto &c = id.get<SPIRConstant>();
bool needs_declaration = c.specialization || c.is_used_as_lut;
if (needs_declaration)
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (!options.vulkan_semantics && c.specialization)
{
c.specialization_constant_macro_name =
Run format_all.sh.
2019-07-23 10:23:41 +00:00
constant_value_macro_name(get_decoration(c.self, DecorationSpecId));
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
emit_constant(c);
emitted = true;
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
}
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
else if (id.get_type() == TypeConstantOp)
{
emit_specialization_constant_op(id.get<SPIRConstantOp>());
Declare OpSpecConstantOp up-front on relevant targets. Required, since spec constants can include results from constant ops.
2018-05-15 12:20:16 +00:00
emitted = true;
}
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
else if (id.get_type() == TypeType)
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
{
GLSL: Support ray payloads and hit attributes declared as Block.
2020-05-20 12:51:45 +00:00
auto *type = &id.get<SPIRType>();
Run format_all.sh.
2020-07-01 09:42:58 +00:00
bool is_natural_struct = type->basetype == SPIRType::Struct && type->array.empty() && !type->pointer &&
(!has_decoration(type->self, DecorationBlock) &&
!has_decoration(type->self, DecorationBufferBlock));
GLSL: Support ray payloads and hit attributes declared as Block.
2020-05-20 12:51:45 +00:00
// Special case, ray payload and hit attribute blocks are not really blocks, just regular structs.
Run format_all.sh.
2020-07-01 09:42:58 +00:00
if (type->basetype == SPIRType::Struct && type->pointer &&
has_decoration(type->self, DecorationBlock) &&
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
(type->storage == StorageClassRayPayloadKHR || type->storage == StorageClassIncomingRayPayloadKHR ||
type->storage == StorageClassHitAttributeKHR))
GLSL: Support ray payloads and hit attributes declared as Block.
2020-05-20 12:51:45 +00:00
{
type = &get<SPIRType>(type->parent_type);
is_natural_struct = true;
}
if (is_natural_struct)
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
{
if (emitted)
statement("");
emitted = false;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
GLSL: Support ray payloads and hit attributes declared as Block.
2020-05-20 12:51:45 +00:00
emit_struct(*type);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
}
Interleave undef values with constants and types. Undef values may be of struct type and may be used in constants. Therefore, they must be interleaved with constants and types. Fixes the rest of the Vulkan CTS test `dEQP-VK.spirv_assembly.instruction.compute.opundef.undefined_spec_constant_composite`. (Please excuse the churn in the reference output; it's an inevitable result of this change.)
2022-11-09 04:04:36 +00:00
else if (id.get_type() == TypeUndef)
{
auto &undef = id.get<SPIRUndef>();
auto &type = this->get<SPIRType>(undef.basetype);
// OpUndef can be void for some reason ...
if (type.basetype == SPIRType::Void)
GLSL: Just skip over impossible declarations instead of early-exit.
2024-10-15 09:48:48 +00:00
continue;
Interleave undef values with constants and types. Undef values may be of struct type and may be used in constants. Therefore, they must be interleaved with constants and types. Fixes the rest of the Vulkan CTS test `dEQP-VK.spirv_assembly.instruction.compute.opundef.undefined_spec_constant_composite`. (Please excuse the churn in the reference output; it's an inevitable result of this change.)
2022-11-09 04:04:36 +00:00
GLSL: Ignore bogus constant/undefs which use block types. This is banned in more recent SPIR-V. We cannot implement this in any reasonable way since block types don't participate as normal types in GLSL.
2023-10-11 11:48:25 +00:00
// This will break. It is bogus and should not be legal.
if (type_is_top_level_block(type))
GLSL: Just skip over impossible declarations instead of early-exit.
2024-10-15 09:48:48 +00:00
continue;
GLSL: Ignore bogus constant/undefs which use block types. This is banned in more recent SPIR-V. We cannot implement this in any reasonable way since block types don't participate as normal types in GLSL.
2023-10-11 11:48:25 +00:00
Interleave undef values with constants and types. Undef values may be of struct type and may be used in constants. Therefore, they must be interleaved with constants and types. Fixes the rest of the Vulkan CTS test `dEQP-VK.spirv_assembly.instruction.compute.opundef.undefined_spec_constant_composite`. (Please excuse the churn in the reference output; it's an inevitable result of this change.)
2022-11-09 04:04:36 +00:00
string initializer;
if (options.force_zero_initialized_variables && type_can_zero_initialize(type))
initializer = join(" = ", to_zero_initialized_expression(undef.basetype));
// FIXME: If used in a constant, we must declare it as one.
statement(variable_decl(type, to_name(undef.self), undef.self), initializer, ";");
emitted = true;
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
}
Support arrays which have spec constant size. The size of an array can be a specialization constant or a spec constant op. This complicates things quite a lot. Reflection becomes very painful in the presence of expressions instead of literals so add a new array which expresses this. It is unlikely that we will need to do accurate reflection of interface types which have specialization constant size. SSBOs and UBOs will for now throw exception if a dynamic size is used since it is very difficult to know the real size.
2016-10-03 15:17:11 +00:00
}
if (emitted)
statement("");
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
// If we needed to declare work group size late, check here.
// If the work group size depends on a specialization constant, we need to declare the layout() block
// after constants (and their macros) have been declared.
Run format_all.sh.
2018-11-01 10:23:33 +00:00
if (execution.model == ExecutionModelGLCompute && !options.vulkan_semantics &&
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
(execution.workgroup_size.constant != 0 || execution.flags.get(ExecutionModeLocalSizeId)))
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
{
SpecializationConstant wg_x, wg_y, wg_z;
get_work_group_size_specialization_constants(wg_x, wg_y, wg_z);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
if ((wg_x.id != ConstantID(0)) || (wg_y.id != ConstantID(0)) || (wg_z.id != ConstantID(0)))
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
{
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<string> inputs;
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
build_workgroup_size(inputs, wg_x, wg_y, wg_z);
statement("layout(", merge(inputs), ") in;");
statement("");
}
}
Support arrays which have spec constant size. The size of an array can be a specialization constant or a spec constant op. This complicates things quite a lot. Reflection becomes very painful in the presence of expressions instead of literals so add a new array which expresses this. It is unlikely that we will need to do accurate reflection of interface types which have specialization constant size. SSBOs and UBOs will for now throw exception if a dynamic size is used since it is very difficult to know the real size.
2016-10-03 15:17:11 +00:00
emitted = false;
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
if (ir.addressing_model == AddressingModelPhysicalStorageBuffer64EXT)
{
// Output buffer reference blocks.
// Do this in two stages, one with forward declaration,
// and one without. Buffer reference blocks can reference themselves
// to support things like linked lists.
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
ir.for_each_typed_id<SPIRType>([&](uint32_t id, SPIRType &type) {
GLSL: Forward declare non-block BDA types as well. With non-block structs, we can have pointers in those types too.
2024-01-18 11:56:31 +00:00
if (is_physical_pointer(type))
{
bool emit_type = true;
if (!is_physical_pointer_to_buffer_block(type))
{
// Only forward-declare if we intend to emit it in the non_block_pointer types.
// Otherwise, these are just "benign" pointer types that exist as a result of access chains.
emit_type = std::find(physical_storage_non_block_pointer_types.begin(),
physical_storage_non_block_pointer_types.end(),
id) != physical_storage_non_block_pointer_types.end();
}
if (emit_type)
emit_buffer_reference_block(id, true);
}
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
});
GLSL: Forward declare non-block BDA types as well. With non-block structs, we can have pointers in those types too.
2024-01-18 11:56:31 +00:00
for (auto type : physical_storage_non_block_pointer_types)
emit_buffer_reference_block(type, false);
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
ir.for_each_typed_id<SPIRType>([&](uint32_t id, SPIRType &type) {
if (is_physical_pointer_to_buffer_block(type))
emit_buffer_reference_block(id, false);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
});
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Output UBOs and SSBOs
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(var.basetype);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Add support for "shaderRecordNV" qualifier
2019-06-03 13:25:21 +00:00
bool is_block_storage = type.storage == StorageClassStorageBuffer || type.storage == StorageClassUniform ||
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
type.storage == StorageClassShaderRecordBufferKHR;
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
bool has_block_flags = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) ||
ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock);
Add basic support for StorageClassStorageBuffer. Needs more testing, but seems to work.
2017-09-28 11:28:44 +00:00
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (var.storage != StorageClassFunction && type.pointer && is_block_storage && !is_hidden_variable(var) &&
has_block_flags)
{
emit_buffer_block(var);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Output push constant blocks
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(var.basetype);
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (var.storage != StorageClassFunction && type.pointer && type.storage == StorageClassPushConstant &&
!is_hidden_variable(var))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
emit_push_constant_block(var);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Trace usage of image/sampler variants through calls.
2016-09-10 19:52:22 +00:00
bool skip_separate_image_sampler = !combined_image_samplers.empty() || !options.vulkan_semantics;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Output Uniform Constants (values, samplers, images, etc).
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(var.basetype);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
// If we're remapping separate samplers and images, only emit the combined samplers.
if (skip_separate_image_sampler)
{
// Sampler buffers are always used without a sampler, and they will also work in regular GL.
bool sampler_buffer = type.basetype == SPIRType::Image && type.image.dim == DimBuffer;
bool separate_image = type.basetype == SPIRType::Image && type.image.sampled == 1;
bool separate_sampler = type.basetype == SPIRType::Sampler;
if (!sampler_buffer && (separate_image || separate_sampler))
return;
}
Trace usage of image/sampler variants through calls.
2016-09-10 19:52:22 +00:00
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (var.storage != StorageClassFunction && type.pointer &&
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
(type.storage == StorageClassUniformConstant || type.storage == StorageClassAtomicCounter ||
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
type.storage == StorageClassRayPayloadKHR || type.storage == StorageClassIncomingRayPayloadKHR ||
type.storage == StorageClassCallableDataKHR || type.storage == StorageClassIncomingCallableDataKHR ||
type.storage == StorageClassHitAttributeKHR) &&
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
!is_hidden_variable(var))
{
emit_uniform(var);
emitted = true;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (emitted)
statement("");
emitted = false;
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
bool emitted_base_instance = false;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Output in/out interfaces.
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
Workaround bugs on MSVC. Bug: https://developercommunity.visualstudio.com/content/problem/303996/c-error-c2668-ambiguous-overloaded-in-lambda-with.html
2019-01-11 08:29:28 +00:00
auto &type = this->get<SPIRType>(var.basetype);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
bool is_hidden = is_hidden_variable(var);
// Unused output I/O variables might still be required to implement framebuffer fetch.
if (var.storage == StorageClassOutput && !is_legacy() &&
GLSL: Implement noncoherent framebuffer fetch.
2021-05-21 12:21:13 +00:00
location_is_framebuffer_fetch(get_decoration(var.self, DecorationLocation)) != 0)
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
{
is_hidden = false;
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
if (var.storage != StorageClassFunction && type.pointer &&
(var.storage == StorageClassInput || var.storage == StorageClassOutput) &&
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
interface_variable_exists_in_entry_point(var.self) && !is_hidden)
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
{
ESSL: Vertex shader input doesn't support array types.
2021-11-26 02:06:42 +00:00
if (options.es && get_execution_model() == ExecutionModelVertex && var.storage == StorageClassInput &&
type.array.size() == 1)
{
SPIRV_CROSS_THROW("OpenGL ES doesn't support array input variables in vertex shader.");
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
emit_interface_block(var);
emitted = true;
}
else if (is_builtin_variable(var))
{
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
auto builtin = BuiltIn(get_decoration(var.self, DecorationBuiltIn));
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
// For gl_InstanceIndex emulation on GLES, the API user needs to
// supply this uniform.
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
// The draw parameter extension is soft-enabled on GL with some fallbacks.
if (!options.vulkan_semantics)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
if (!emitted_base_instance &&
((options.vertex.support_nonzero_base_instance && builtin == BuiltInInstanceIndex) ||
(builtin == BuiltInBaseInstance)))
{
statement("#ifdef GL_ARB_shader_draw_parameters");
statement("#define SPIRV_Cross_BaseInstance gl_BaseInstanceARB");
statement("#else");
// A crude, but simple workaround which should be good enough for non-indirect draws.
statement("uniform int SPIRV_Cross_BaseInstance;");
statement("#endif");
emitted = true;
emitted_base_instance = true;
}
else if (builtin == BuiltInBaseVertex)
{
statement("#ifdef GL_ARB_shader_draw_parameters");
statement("#define SPIRV_Cross_BaseVertex gl_BaseVertexARB");
statement("#else");
// A crude, but simple workaround which should be good enough for non-indirect draws.
statement("uniform int SPIRV_Cross_BaseVertex;");
statement("#endif");
}
else if (builtin == BuiltInDrawIndex)
{
statement("#ifndef GL_ARB_shader_draw_parameters");
// Cannot really be worked around.
statement("#error GL_ARB_shader_draw_parameters is not supported.");
statement("#endif");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
Rewrite how IDs are iterated over. This is a fairly fundamental change on how IDs are handled. It serves many purposes: - Improve performance. We only need to iterate over IDs which are relevant at any one time. - Makes sure we iterate through IDs in SPIR-V module declaration order rather than ID space. IDs don't have to be monotonically increasing, which was an assumption SPIRV-Cross used to have. It has apparently never been a problem until now. - Support LUTs of structs. We do this by interleaving declaration of constants and struct types in SPIR-V module order. To support this, the ParsedIR interface needed to change slightly. Before setting any ID with variant_set<T> we let ParsedIR know that an ID with a specific type has been added. The surface for change should be minimal. ParsedIR will maintain a per-type list of IDs which the cross-compiler will need to consider for later. Instead of looping over ir.ids[] (which can be extremely large), we loop over types now, using: ir.for_each_typed_id<SPIRVariable>([&](uint32_t id, SPIRVariable &var) { handle_variable(var); }); Now we make sure that we're never looking at irrelevant types.
2019-01-10 08:49:33 +00:00
});
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Global variables.
for (auto global : global_variables)
{
auto &var = get<SPIRVariable>(global);
Check entry point variables in is_hidden_variables. Need to be careful not to emit globals we're not supposed to.
2021-01-22 12:48:16 +00:00
if (is_hidden_variable(var, true))
continue;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (var.storage != StorageClassOutput)
{
Support LUTs in single-function CFGs on Private storage class. Fairly common pattern in unoptimized SPIR-V. Support this case as well.
2019-02-06 09:38:18 +00:00
if (!variable_is_lut(var))
{
add_resource_name(var.self);
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
string initializer;
if (options.force_zero_initialized_variables && var.storage == StorageClassPrivate &&
!var.initializer && !var.static_expression && type_can_zero_initialize(get_variable_data_type(var)))
{
initializer = join(" = ", to_zero_initialized_expression(get_variable_data_type_id(var)));
}
statement(variable_decl(var), initializer, ";");
Support LUTs in single-function CFGs on Private storage class. Fairly common pattern in unoptimized SPIR-V. Support this case as well.
2019-02-06 09:38:18 +00:00
emitted = true;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Handle output IO block initializers more robustly.
2021-01-04 10:16:58 +00:00
else if (var.initializer && maybe_get<SPIRConstant>(var.initializer) != nullptr)
{
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
emit_output_variable_initializer(var);
}
}
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
if (emitted)
statement("");
}
More robust handling of initialized output builtin variables.
2021-01-04 10:58:50 +00:00
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
void CompilerGLSL::emit_output_variable_initializer(const SPIRVariable &var)
{
// If a StorageClassOutput variable has an initializer, we need to initialize it in main().
auto &entry_func = this->get<SPIRFunction>(ir.default_entry_point);
auto &type = get<SPIRType>(var.basetype);
bool is_patch = has_decoration(var.self, DecorationPatch);
bool is_block = has_decoration(type.self, DecorationBlock);
bool is_control_point = get_execution_model() == ExecutionModelTessellationControl && !is_patch;
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
if (is_block)
{
uint32_t member_count = uint32_t(type.member_types.size());
GLSL: Fix -Wshadow error.
2021-01-06 11:59:57 +00:00
bool type_is_array = type.array.size() == 1;
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
uint32_t array_size = 1;
GLSL: Fix -Wshadow error.
2021-01-06 11:59:57 +00:00
if (type_is_array)
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
array_size = to_array_size_literal(type);
uint32_t iteration_count = is_control_point ? 1 : array_size;
// If the initializer is a block, we must initialize each block member one at a time.
for (uint32_t i = 0; i < member_count; i++)
{
// These outputs might not have been properly declared, so don't initialize them in that case.
if (has_member_decoration(type.self, i, DecorationBuiltIn))
{
if (get_member_decoration(type.self, i, DecorationBuiltIn) == BuiltInCullDistance &&
!cull_distance_count)
continue;
if (get_member_decoration(type.self, i, DecorationBuiltIn) == BuiltInClipDistance &&
!clip_distance_count)
continue;
Handle output IO block initializers more robustly.
2021-01-04 10:16:58 +00:00
}
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
// We need to build a per-member array first, essentially transposing from AoS to SoA.
// This code path hits when we have an array of blocks.
string lut_name;
GLSL: Fix -Wshadow error.
2021-01-06 11:59:57 +00:00
if (type_is_array)
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
{
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
lut_name = join("_", var.self, "_", i, "_init");
uint32_t member_type_id = get<SPIRType>(var.basetype).member_types[i];
auto &member_type = get<SPIRType>(member_type_id);
auto array_type = member_type;
array_type.parent_type = member_type_id;
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
array_type.op = OpTypeArray;
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
array_type.array.push_back(array_size);
array_type.array_size_literal.push_back(true);
SmallVector<string> exprs;
exprs.reserve(array_size);
auto &c = get<SPIRConstant>(var.initializer);
for (uint32_t j = 0; j < array_size; j++)
exprs.push_back(to_expression(get<SPIRConstant>(c.subconstants[j]).subconstants[i]));
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
statement("const ", type_to_glsl(array_type), " ", lut_name, type_to_array_glsl(array_type, 0), " = ",
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
type_to_glsl_constructor(array_type), "(", merge(exprs, ", "), ");");
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
}
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
for (uint32_t j = 0; j < iteration_count; j++)
Handle output IO block initializers more robustly.
2021-01-04 10:16:58 +00:00
{
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
entry_func.fixup_hooks_in.push_back([=, &var]() {
AccessChainMeta meta;
auto &c = this->get<SPIRConstant>(var.initializer);
uint32_t invocation_id = 0;
uint32_t member_index_id = 0;
if (is_control_point)
{
uint32_t ids = ir.increase_bound_by(3);
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
auto &uint_type = set<SPIRType>(ids, OpTypeInt);
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
uint_type.basetype = SPIRType::UInt;
uint_type.width = 32;
set<SPIRExpression>(ids + 1, builtin_to_glsl(BuiltInInvocationId, StorageClassInput), ids, true);
set<SPIRConstant>(ids + 2, ids, i, false);
invocation_id = ids + 1;
member_index_id = ids + 2;
}
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
if (is_patch)
{
statement("if (gl_InvocationID == 0)");
begin_scope();
}
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
GLSL: Fix -Wshadow error.
2021-01-06 11:59:57 +00:00
if (type_is_array && !is_control_point)
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
{
uint32_t indices[2] = { j, i };
auto chain = access_chain_internal(var.self, indices, 2, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &meta);
statement(chain, " = ", lut_name, "[", j, "];");
}
else if (is_control_point)
{
uint32_t indices[2] = { invocation_id, member_index_id };
auto chain = access_chain_internal(var.self, indices, 2, 0, &meta);
statement(chain, " = ", lut_name, "[", builtin_to_glsl(BuiltInInvocationId, StorageClassInput), "];");
}
else
{
auto chain =
access_chain_internal(var.self, &i, 1, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &meta);
statement(chain, " = ", to_expression(c.subconstants[i]), ";");
}
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
if (is_patch)
end_scope();
});
Handle output IO block initializers more robustly.
2021-01-04 10:16:58 +00:00
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
else if (is_control_point)
{
auto lut_name = join("_", var.self, "_init");
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
statement("const ", type_to_glsl(type), " ", lut_name, type_to_array_glsl(type, 0),
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
" = ", to_expression(var.initializer), ";");
entry_func.fixup_hooks_in.push_back([&, lut_name]() {
statement(to_expression(var.self), "[gl_InvocationID] = ", lut_name, "[gl_InvocationID];");
});
}
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
else if (has_decoration(var.self, DecorationBuiltIn) &&
BuiltIn(get_decoration(var.self, DecorationBuiltIn)) == BuiltInSampleMask)
{
// We cannot copy the array since gl_SampleMask is unsized in GLSL. Unroll time! <_<
entry_func.fixup_hooks_in.push_back([&] {
auto &c = this->get<SPIRConstant>(var.initializer);
uint32_t num_constants = uint32_t(c.subconstants.size());
for (uint32_t i = 0; i < num_constants; i++)
{
// Don't use to_expression on constant since it might be uint, just fish out the raw int.
statement(to_expression(var.self), "[", i, "] = ",
convert_to_string(this->get<SPIRConstant>(c.subconstants[i]).scalar_i32()), ";");
}
});
}
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
else
{
auto lut_name = join("_", var.self, "_init");
statement("const ", type_to_glsl(type), " ", lut_name,
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
type_to_array_glsl(type, var.self), " = ", to_expression(var.initializer), ";");
GLSL: Refactor out Output variable initialization.
2021-01-05 11:50:36 +00:00
entry_func.fixup_hooks_in.push_back([&, lut_name, is_patch]() {
if (is_patch)
{
statement("if (gl_InvocationID == 0)");
begin_scope();
}
statement(to_expression(var.self), " = ", lut_name, ";");
if (is_patch)
end_scope();
});
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
GLSL: Address review comments Fix a warning and some format issues
2023-05-01 11:24:33 +00:00
void CompilerGLSL::emit_subgroup_arithmetic_workaround(const std::string &func, Op op, GroupOperation group_op)
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
{
std::string result;
switch (group_op)
{
case GroupOperationReduce:
result = "reduction";
break;
case GroupOperationExclusiveScan:
result = "excl_scan";
break;
case GroupOperationInclusiveScan:
result = "incl_scan";
break;
default:
SPIRV_CROSS_THROW("Unsupported workaround for arithmetic group operation");
}
struct TypeInfo
{
std::string type;
std::string identity;
};
std::vector<TypeInfo> type_infos;
switch (op)
{
case OpGroupNonUniformIAdd:
{
type_infos.emplace_back(TypeInfo{ "uint", "0u" });
type_infos.emplace_back(TypeInfo{ "uvec2", "uvec2(0u)" });
type_infos.emplace_back(TypeInfo{ "uvec3", "uvec3(0u)" });
type_infos.emplace_back(TypeInfo{ "uvec4", "uvec4(0u)" });
type_infos.emplace_back(TypeInfo{ "int", "0" });
type_infos.emplace_back(TypeInfo{ "ivec2", "ivec2(0)" });
type_infos.emplace_back(TypeInfo{ "ivec3", "ivec3(0)" });
type_infos.emplace_back(TypeInfo{ "ivec4", "ivec4(0)" });
break;
}
GLSL: Support KHR_subgroup_arithmetic FAdd Support NV workarounds for FAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-02 07:45:25 +00:00
case OpGroupNonUniformFAdd:
{
type_infos.emplace_back(TypeInfo{ "float", "0.0f" });
type_infos.emplace_back(TypeInfo{ "vec2", "vec2(0.0f)" });
type_infos.emplace_back(TypeInfo{ "vec3", "vec3(0.0f)" });
type_infos.emplace_back(TypeInfo{ "vec4", "vec4(0.0f)" });
// ARB_gpu_shader_fp64 is required in GL4.0 which in turn is required by NV_thread_shuffle
type_infos.emplace_back(TypeInfo{ "double", "0.0LF" });
type_infos.emplace_back(TypeInfo{ "dvec2", "dvec2(0.0LF)" });
type_infos.emplace_back(TypeInfo{ "dvec3", "dvec3(0.0LF)" });
type_infos.emplace_back(TypeInfo{ "dvec4", "dvec4(0.0LF)" });
break;
}
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
case OpGroupNonUniformIMul:
{
type_infos.emplace_back(TypeInfo{ "uint", "1u" });
type_infos.emplace_back(TypeInfo{ "uvec2", "uvec2(1u)" });
type_infos.emplace_back(TypeInfo{ "uvec3", "uvec3(1u)" });
type_infos.emplace_back(TypeInfo{ "uvec4", "uvec4(1u)" });
type_infos.emplace_back(TypeInfo{ "int", "1" });
type_infos.emplace_back(TypeInfo{ "ivec2", "ivec2(1)" });
type_infos.emplace_back(TypeInfo{ "ivec3", "ivec3(1)" });
type_infos.emplace_back(TypeInfo{ "ivec4", "ivec4(1)" });
break;
}
case OpGroupNonUniformFMul:
{
type_infos.emplace_back(TypeInfo{ "float", "1.0f" });
type_infos.emplace_back(TypeInfo{ "vec2", "vec2(1.0f)" });
type_infos.emplace_back(TypeInfo{ "vec3", "vec3(1.0f)" });
type_infos.emplace_back(TypeInfo{ "vec4", "vec4(1.0f)" });
type_infos.emplace_back(TypeInfo{ "double", "0.0LF" });
type_infos.emplace_back(TypeInfo{ "dvec2", "dvec2(1.0LF)" });
type_infos.emplace_back(TypeInfo{ "dvec3", "dvec3(1.0LF)" });
type_infos.emplace_back(TypeInfo{ "dvec4", "dvec4(1.0LF)" });
break;
}
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
default:
SPIRV_CROSS_THROW("Unsupported workaround for arithmetic group operation");
}
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
const bool op_is_addition = op == OpGroupNonUniformIAdd || op == OpGroupNonUniformFAdd;
const bool op_is_multiplication = op == OpGroupNonUniformIMul || op == OpGroupNonUniformFMul;
std::string op_symbol;
if (op_is_addition)
{
op_symbol = "+=";
}
else if (op_is_multiplication)
{
op_symbol = "*=";
}
GLSL: Address review comments Fix a warning and some format issues
2023-05-01 11:24:33 +00:00
for (const TypeInfo &t : type_infos)
{
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
statement(t.type, " ", func, "(", t.type, " v)");
begin_scope();
statement(t.type, " ", result, " = ", t.identity, ";");
GLSL: Checking for inactive threads in non uniform arithmetic ops The last argument of shuffle*NV functions does not return if the current thread is inactive, but only if it is out of range.
2023-04-03 15:42:08 +00:00
statement("uvec4 active_threads = subgroupBallot(true);");
statement("if (subgroupBallotBitCount(active_threads) == gl_SubgroupSize)");
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
begin_scope();
statement("uint total = gl_SubgroupSize / 2u;");
statement(result, " = v;");
statement("for (uint i = 1u; i <= total; i <<= 1u)");
begin_scope();
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
statement("bool valid;");
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
if (group_op == GroupOperationReduce)
{
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
statement(t.type, " s = shuffleXorNV(", result, ", i, gl_SubgroupSize, valid);");
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
}
else if (group_op == GroupOperationExclusiveScan || group_op == GroupOperationInclusiveScan)
{
statement(t.type, " s = shuffleUpNV(", result, ", i, gl_SubgroupSize, valid);");
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
}
if (op_is_addition || op_is_multiplication)
{
statement(result, " ", op_symbol, " valid ? s : ", t.identity, ";");
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
}
end_scope();
if (group_op == GroupOperationExclusiveScan)
{
statement(result, " = shuffleUpNV(", result, ", 1u, gl_SubgroupSize);");
statement("if (subgroupElect())");
begin_scope();
statement(result, " = ", t.identity, ";");
end_scope();
}
end_scope();
statement("else");
begin_scope();
if (group_op == GroupOperationExclusiveScan)
{
statement("uint total = subgroupBallotBitCount(gl_SubgroupLtMask);");
}
else if (group_op == GroupOperationInclusiveScan)
{
statement("uint total = subgroupBallotBitCount(gl_SubgroupLeMask);");
}
statement("for (uint i = 0u; i < gl_SubgroupSize; ++i)");
begin_scope();
GLSL: Checking for inactive threads in non uniform arithmetic ops The last argument of shuffle*NV functions does not return if the current thread is inactive, but only if it is out of range.
2023-04-03 15:42:08 +00:00
statement("bool valid = subgroupBallotBitExtract(active_threads, i);");
statement(t.type, " s = shuffleNV(v, i, gl_SubgroupSize);");
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
if (group_op == GroupOperationExclusiveScan || group_op == GroupOperationInclusiveScan)
{
statement("valid = valid && (i < total);");
}
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
if (op_is_addition || op_is_multiplication)
{
statement(result, " ", op_symbol, " valid ? s : ", t.identity, ";");
}
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
end_scope();
end_scope();
statement("return ", result, ";");
end_scope();
}
}
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
void CompilerGLSL::emit_extension_workarounds(spv::ExecutionModel model)
{
Run format_all.sh.
2020-11-08 12:59:52 +00:00
static const char *workaround_types[] = { "int", "ivec2", "ivec3", "ivec4", "uint", "uvec2", "uvec3", "uvec4",
"float", "vec2", "vec3", "vec4", "double", "dvec2", "dvec3", "dvec4" };
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (!options.vulkan_semantics)
{
using Supp = ShaderSubgroupSupportHelper;
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto result = shader_subgroup_supporter.resolve();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupMask))
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto exts = Supp::get_candidates_for_feature(Supp::SubgroupMask, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &e : exts)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
switch (e)
{
case Supp::NV_shader_thread_group:
statement("#define gl_SubgroupEqMask uvec4(gl_ThreadEqMaskNV, 0u, 0u, 0u)");
statement("#define gl_SubgroupGeMask uvec4(gl_ThreadGeMaskNV, 0u, 0u, 0u)");
statement("#define gl_SubgroupGtMask uvec4(gl_ThreadGtMaskNV, 0u, 0u, 0u)");
statement("#define gl_SubgroupLeMask uvec4(gl_ThreadLeMaskNV, 0u, 0u, 0u)");
statement("#define gl_SubgroupLtMask uvec4(gl_ThreadLtMaskNV, 0u, 0u, 0u)");
break;
case Supp::ARB_shader_ballot:
statement("#define gl_SubgroupEqMask uvec4(unpackUint2x32(gl_SubGroupEqMaskARB), 0u, 0u)");
statement("#define gl_SubgroupGeMask uvec4(unpackUint2x32(gl_SubGroupGeMaskARB), 0u, 0u)");
statement("#define gl_SubgroupGtMask uvec4(unpackUint2x32(gl_SubGroupGtMaskARB), 0u, 0u)");
statement("#define gl_SubgroupLeMask uvec4(unpackUint2x32(gl_SubGroupLeMaskARB), 0u, 0u)");
statement("#define gl_SubgroupLtMask uvec4(unpackUint2x32(gl_SubGroupLtMaskARB), 0u, 0u)");
break;
default:
break;
}
}
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupSize))
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto exts = Supp::get_candidates_for_feature(Supp::SubgroupSize, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &e : exts)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
switch (e)
{
case Supp::NV_shader_thread_group:
statement("#define gl_SubgroupSize gl_WarpSizeNV");
break;
case Supp::ARB_shader_ballot:
statement("#define gl_SubgroupSize gl_SubGroupSizeARB");
break;
case Supp::AMD_gcn_shader:
statement("#define gl_SubgroupSize uint(gl_SIMDGroupSizeAMD)");
break;
default:
break;
}
}
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupInvocationID))
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto exts = Supp::get_candidates_for_feature(Supp::SubgroupInvocationID, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &e : exts)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
switch (e)
{
case Supp::NV_shader_thread_group:
statement("#define gl_SubgroupInvocationID gl_ThreadInWarpNV");
break;
case Supp::ARB_shader_ballot:
statement("#define gl_SubgroupInvocationID gl_SubGroupInvocationARB");
break;
default:
break;
}
}
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupID))
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto exts = Supp::get_candidates_for_feature(Supp::SubgroupID, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &e : exts)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
switch (e)
{
case Supp::NV_shader_thread_group:
statement("#define gl_SubgroupID gl_WarpIDNV");
break;
default:
break;
}
}
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::NumSubgroups))
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto exts = Supp::get_candidates_for_feature(Supp::NumSubgroups, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &e : exts)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
switch (e)
{
case Supp::NV_shader_thread_group:
statement("#define gl_NumSubgroups gl_WarpsPerSMNV");
break;
default:
break;
}
}
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
GLSL: Fix KHR subgroup extension table for subgroups.
2020-12-11 11:24:34 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBroadcast_First))
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
GLSL: Fix KHR subgroup extension table for subgroups.
2020-12-11 11:24:34 +00:00
auto exts = Supp::get_candidates_for_feature(Supp::SubgroupBroadcast_First, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &e : exts)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
switch (e)
{
case Supp::NV_shader_thread_shuffle:
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (const char *t : workaround_types)
{
statement(t, " subgroupBroadcastFirst(", t,
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
" value) { return shuffleNV(value, findLSB(ballotThreadNV(true)), gl_WarpSizeNV); }");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
}
for (const char *t : workaround_types)
{
statement(t, " subgroupBroadcast(", t,
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
" value, uint id) { return shuffleNV(value, id, gl_WarpSizeNV); }");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
}
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
break;
case Supp::ARB_shader_ballot:
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (const char *t : workaround_types)
{
statement(t, " subgroupBroadcastFirst(", t,
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
" value) { return readFirstInvocationARB(value); }");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
}
for (const char *t : workaround_types)
{
statement(t, " subgroupBroadcast(", t,
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
" value, uint id) { return readInvocationARB(value, id); }");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
}
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
break;
default:
break;
}
}
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBallotFindLSB_MSB))
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto exts = Supp::get_candidates_for_feature(Supp::SubgroupBallotFindLSB_MSB, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &e : exts)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
switch (e)
{
case Supp::NV_shader_thread_group:
statement("uint subgroupBallotFindLSB(uvec4 value) { return findLSB(value.x); }");
statement("uint subgroupBallotFindMSB(uvec4 value) { return findMSB(value.x); }");
break;
default:
break;
}
}
statement("#else");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("uint subgroupBallotFindLSB(uvec4 value)");
begin_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("int firstLive = findLSB(value.x);");
statement("return uint(firstLive != -1 ? firstLive : (findLSB(value.y) + 32));");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
end_scope();
statement("uint subgroupBallotFindMSB(uvec4 value)");
begin_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("int firstLive = findMSB(value.y);");
statement("return uint(firstLive != -1 ? (firstLive + 32) : findMSB(value.x));");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
end_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupAll_Any_AllEqualBool))
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto exts = Supp::get_candidates_for_feature(Supp::SubgroupAll_Any_AllEqualBool, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &e : exts)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
switch (e)
{
case Supp::NV_gpu_shader_5:
statement("bool subgroupAll(bool value) { return allThreadsNV(value); }");
statement("bool subgroupAny(bool value) { return anyThreadNV(value); }");
statement("bool subgroupAllEqual(bool value) { return allThreadsEqualNV(value); }");
break;
case Supp::ARB_shader_group_vote:
statement("bool subgroupAll(bool v) { return allInvocationsARB(v); }");
statement("bool subgroupAny(bool v) { return anyInvocationARB(v); }");
statement("bool subgroupAllEqual(bool v) { return allInvocationsEqualARB(v); }");
break;
case Supp::AMD_gcn_shader:
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("bool subgroupAll(bool value) { return ballotAMD(value) == ballotAMD(true); }");
statement("bool subgroupAny(bool value) { return ballotAMD(value) != 0ull; }");
statement("bool subgroupAllEqual(bool value) { uint64_t b = ballotAMD(value); return b == 0ull || "
"b == ballotAMD(true); }");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
break;
default:
break;
}
}
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupAllEqualT))
{
statement("#ifndef GL_KHR_shader_subgroup_vote");
statement(
"#define _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(type) bool subgroupAllEqual(type value) { return "
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
"subgroupAllEqual(subgroupBroadcastFirst(value) == value); }");
for (const char *t : workaround_types)
statement("_SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND(", t, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("#undef _SPIRV_CROSS_SUBGROUP_ALL_EQUAL_WORKAROUND");
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBallot))
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto exts = Supp::get_candidates_for_feature(Supp::SubgroupBallot, result);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &e : exts)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
switch (e)
{
case Supp::NV_shader_thread_group:
statement("uvec4 subgroupBallot(bool v) { return uvec4(ballotThreadNV(v), 0u, 0u, 0u); }");
break;
case Supp::ARB_shader_ballot:
statement("uvec4 subgroupBallot(bool v) { return uvec4(unpackUint2x32(ballotARB(v)), 0u, 0u); }");
break;
default:
break;
}
}
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupElect))
{
statement("#ifndef GL_KHR_shader_subgroup_basic");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("bool subgroupElect()");
begin_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("uvec4 activeMask = subgroupBallot(true);");
statement("uint firstLive = subgroupBallotFindLSB(activeMask);");
statement("return gl_SubgroupInvocationID == firstLive;");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
end_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBarrier))
{
// Extensions we're using in place of GL_KHR_shader_subgroup_basic state
// that subgroup execute in lockstep so this barrier is implicit.
Fix some bad assumptions about emulating `subgroupBarrier`
2020-10-31 20:46:59 +00:00
// However the GL 4.6 spec also states that `barrier` implies a shared memory barrier,
// and a specific test of optimizing scans by leveraging lock-step invocation execution,
// has shown that a `memoryBarrierShared` is needed in place of a `subgroupBarrier`.
// https://github.com/buildaworldnet/IrrlichtBAW/commit/d8536857991b89a30a6b65d29441e51b64c2c7ad#diff-9f898d27be1ea6fc79b03d9b361e299334c1a347b6e4dc344ee66110c6aa596aR19
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("#ifndef GL_KHR_shader_subgroup_basic");
Fix some bad assumptions about emulating `subgroupBarrier`
2020-10-31 20:46:59 +00:00
statement("void subgroupBarrier() { memoryBarrierShared(); }");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupMemBarrier))
{
if (model == spv::ExecutionModelGLCompute)
{
statement("#ifndef GL_KHR_shader_subgroup_basic");
statement("void subgroupMemoryBarrier() { groupMemoryBarrier(); }");
statement("void subgroupMemoryBarrierBuffer() { groupMemoryBarrier(); }");
Fix some bad assumptions about emulating `subgroupBarrier`
2020-10-31 20:46:59 +00:00
statement("void subgroupMemoryBarrierShared() { memoryBarrierShared(); }");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("void subgroupMemoryBarrierImage() { groupMemoryBarrier(); }");
statement("#endif");
}
else
{
statement("#ifndef GL_KHR_shader_subgroup_basic");
statement("void subgroupMemoryBarrier() { memoryBarrier(); }");
statement("void subgroupMemoryBarrierBuffer() { memoryBarrierBuffer(); }");
statement("void subgroupMemoryBarrierImage() { memoryBarrierImage(); }");
statement("#endif");
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupInverseBallot_InclBitCount_ExclBitCout))
{
statement("#ifndef GL_KHR_shader_subgroup_ballot");
statement("bool subgroupInverseBallot(uvec4 value)");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
begin_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("return any(notEqual(value.xy & gl_SubgroupEqMask.xy, uvec2(0u)));");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
end_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("uint subgroupBallotInclusiveBitCount(uvec4 value)");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
begin_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("uvec2 v = value.xy & gl_SubgroupLeMask.xy;");
statement("ivec2 c = bitCount(v);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#ifdef GL_NV_shader_thread_group");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("return uint(c.x);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#else");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("return uint(c.x + c.y);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#endif");
end_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("uint subgroupBallotExclusiveBitCount(uvec4 value)");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
begin_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("uvec2 v = value.xy & gl_SubgroupLtMask.xy;");
statement("ivec2 c = bitCount(v);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#ifdef GL_NV_shader_thread_group");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("return uint(c.x);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#else");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("return uint(c.x + c.y);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#endif");
end_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBallotBitCount))
{
statement("#ifndef GL_KHR_shader_subgroup_ballot");
statement("uint subgroupBallotBitCount(uvec4 value)");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
begin_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("ivec2 c = bitCount(value.xy);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#ifdef GL_NV_shader_thread_group");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("return uint(c.x);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#else");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("return uint(c.x + c.y);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#endif");
end_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
if (shader_subgroup_supporter.is_feature_requested(Supp::SubgroupBallotBitExtract))
{
statement("#ifndef GL_KHR_shader_subgroup_ballot");
statement("bool subgroupBallotBitExtract(uvec4 value, uint index)");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
begin_scope();
statement_no_indent("#ifdef GL_NV_shader_thread_group");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("uint shifted = value.x >> index;");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#else");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("uint shifted = value[index >> 5u] >> (index & 0x1fu);");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement_no_indent("#endif");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("return (shifted & 1u) != 0u;");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
end_scope();
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
statement("#endif");
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
statement("");
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
auto arithmetic_feature_helper =
[&](Supp::Feature feat, std::string func_name, spv::Op op, spv::GroupOperation group_op)
{
if (shader_subgroup_supporter.is_feature_requested(feat))
{
auto exts = Supp::get_candidates_for_feature(feat, result);
for (auto &e : exts)
{
const char *name = Supp::get_extension_name(e);
statement(&e == &exts.front() ? "#if" : "#elif", " defined(", name, ")");
switch (e)
{
case Supp::NV_shader_thread_shuffle:
emit_subgroup_arithmetic_workaround(func_name, op, group_op);
break;
default:
break;
}
}
statement("#endif");
statement("");
}
};
arithmetic_feature_helper(Supp::SubgroupArithmeticIAddReduce, "subgroupAdd", OpGroupNonUniformIAdd,
GroupOperationReduce);
arithmetic_feature_helper(Supp::SubgroupArithmeticIAddExclusiveScan, "subgroupExclusiveAdd",
OpGroupNonUniformIAdd, GroupOperationExclusiveScan);
arithmetic_feature_helper(Supp::SubgroupArithmeticIAddInclusiveScan, "subgroupInclusiveAdd",
OpGroupNonUniformIAdd, GroupOperationInclusiveScan);
GLSL: Support KHR_subgroup_arithmetic FAdd Support NV workarounds for FAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-02 07:45:25 +00:00
arithmetic_feature_helper(Supp::SubgroupArithmeticFAddReduce, "subgroupAdd", OpGroupNonUniformFAdd,
GroupOperationReduce);
arithmetic_feature_helper(Supp::SubgroupArithmeticFAddExclusiveScan, "subgroupExclusiveAdd",
OpGroupNonUniformFAdd, GroupOperationExclusiveScan);
arithmetic_feature_helper(Supp::SubgroupArithmeticFAddInclusiveScan, "subgroupInclusiveAdd",
OpGroupNonUniformFAdd, GroupOperationInclusiveScan);
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
arithmetic_feature_helper(Supp::SubgroupArithmeticIMulReduce, "subgroupMul", OpGroupNonUniformIMul,
GroupOperationReduce);
arithmetic_feature_helper(Supp::SubgroupArithmeticIMulExclusiveScan, "subgroupExclusiveMul",
OpGroupNonUniformIMul, GroupOperationExclusiveScan);
arithmetic_feature_helper(Supp::SubgroupArithmeticIMulInclusiveScan, "subgroupInclusiveMul",
OpGroupNonUniformIMul, GroupOperationInclusiveScan);
arithmetic_feature_helper(Supp::SubgroupArithmeticFMulReduce, "subgroupMul", OpGroupNonUniformFMul,
GroupOperationReduce);
arithmetic_feature_helper(Supp::SubgroupArithmeticFMulExclusiveScan, "subgroupExclusiveMul",
OpGroupNonUniformFMul, GroupOperationExclusiveScan);
arithmetic_feature_helper(Supp::SubgroupArithmeticFMulInclusiveScan, "subgroupInclusiveMul",
OpGroupNonUniformFMul, GroupOperationInclusiveScan);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
if (!workaround_ubo_load_overload_types.empty())
{
for (auto &type_id : workaround_ubo_load_overload_types)
{
auto &type = get<SPIRType>(type_id);
GLSL: Fix row-major workaround wrapper for ES. By default, the matrix would be declared as mediump, causing precision issues. Need to dispatch to two separate functions since GLSL does not support overload based on precision.
2022-12-13 14:38:58 +00:00
if (options.es && is_matrix(type))
{
// Need both variants.
// GLSL cannot overload on precision, so need to dispatch appropriately.
statement("highp ", type_to_glsl(type), " spvWorkaroundRowMajor(highp ", type_to_glsl(type), " wrap) { return wrap; }");
statement("mediump ", type_to_glsl(type), " spvWorkaroundRowMajorMP(mediump ", type_to_glsl(type), " wrap) { return wrap; }");
}
else
{
statement(type_to_glsl(type), " spvWorkaroundRowMajor(", type_to_glsl(type), " wrap) { return wrap; }");
}
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
}
statement("");
}
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
}
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
void CompilerGLSL::emit_polyfills(uint32_t polyfills, bool relaxed)
{
const char *qual = "";
const char *suffix = (options.es && relaxed) ? "MP" : "";
if (options.es)
qual = relaxed ? "mediump " : "highp ";
if (polyfills & PolyfillTranspose2x2)
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
{
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
statement(qual, "mat2 spvTranspose", suffix, "(", qual, "mat2 m)");
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
begin_scope();
statement("return mat2(m[0][0], m[1][0], m[0][1], m[1][1]);");
end_scope();
statement("");
}
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
if (polyfills & PolyfillTranspose3x3)
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
{
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
statement(qual, "mat3 spvTranspose", suffix, "(", qual, "mat3 m)");
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
begin_scope();
statement("return mat3(m[0][0], m[1][0], m[2][0], m[0][1], m[1][1], m[2][1], m[0][2], m[1][2], m[2][2]);");
end_scope();
statement("");
}
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
if (polyfills & PolyfillTranspose4x4)
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
{
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
statement(qual, "mat4 spvTranspose", suffix, "(", qual, "mat4 m)");
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
begin_scope();
Run format_all.sh.
2020-11-08 12:59:52 +00:00
statement("return mat4(m[0][0], m[1][0], m[2][0], m[3][0], m[0][1], m[1][1], m[2][1], m[3][1], m[0][2], "
"m[1][2], m[2][2], m[3][2], m[0][3], m[1][3], m[2][3], m[3][3]);");
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
end_scope();
statement("");
}
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
if (polyfills & PolyfillDeterminant2x2)
{
GLSL: Fix missing precision qualifier in spvDeterminant return value Follow-up to #2100
2023-01-27 20:44:47 +00:00
statement(qual, "float spvDeterminant", suffix, "(", qual, "mat2 m)");
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
begin_scope();
statement("return m[0][0] * m[1][1] - m[0][1] * m[1][0];");
end_scope();
statement("");
}
if (polyfills & PolyfillDeterminant3x3)
{
GLSL: Fix missing precision qualifier in spvDeterminant return value Follow-up to #2100
2023-01-27 20:44:47 +00:00
statement(qual, "float spvDeterminant", suffix, "(", qual, "mat3 m)");
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
begin_scope();
statement("return dot(m[0], vec3(m[1][1] * m[2][2] - m[1][2] * m[2][1], "
"m[1][2] * m[2][0] - m[1][0] * m[2][2], "
"m[1][0] * m[2][1] - m[1][1] * m[2][0]));");
end_scope();
statement("");
}
if (polyfills & PolyfillDeterminant4x4)
{
GLSL: Fix missing precision qualifier in spvDeterminant return value Follow-up to #2100
2023-01-27 20:44:47 +00:00
statement(qual, "float spvDeterminant", suffix, "(", qual, "mat4 m)");
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
begin_scope();
statement("return dot(m[0], vec4("
"m[2][1] * m[3][2] * m[1][3] - m[3][1] * m[2][2] * m[1][3] + m[3][1] * m[1][2] * m[2][3] - m[1][1] * m[3][2] * m[2][3] - m[2][1] * m[1][2] * m[3][3] + m[1][1] * m[2][2] * m[3][3], "
"m[3][0] * m[2][2] * m[1][3] - m[2][0] * m[3][2] * m[1][3] - m[3][0] * m[1][2] * m[2][3] + m[1][0] * m[3][2] * m[2][3] + m[2][0] * m[1][2] * m[3][3] - m[1][0] * m[2][2] * m[3][3], "
"m[2][0] * m[3][1] * m[1][3] - m[3][0] * m[2][1] * m[1][3] + m[3][0] * m[1][1] * m[2][3] - m[1][0] * m[3][1] * m[2][3] - m[2][0] * m[1][1] * m[3][3] + m[1][0] * m[2][1] * m[3][3], "
"m[3][0] * m[2][1] * m[1][2] - m[2][0] * m[3][1] * m[1][2] - m[3][0] * m[1][1] * m[2][2] + m[1][0] * m[3][1] * m[2][2] + m[2][0] * m[1][1] * m[3][2] - m[1][0] * m[2][1] * m[3][2]));");
end_scope();
statement("");
}
if (polyfills & PolyfillMatrixInverse2x2)
{
statement(qual, "mat2 spvInverse", suffix, "(", qual, "mat2 m)");
begin_scope();
statement("return mat2(m[1][1], -m[0][1], -m[1][0], m[0][0]) "
"* (1.0 / (m[0][0] * m[1][1] - m[1][0] * m[0][1]));");
end_scope();
statement("");
}
if (polyfills & PolyfillMatrixInverse3x3)
{
statement(qual, "mat3 spvInverse", suffix, "(", qual, "mat3 m)");
begin_scope();
statement(qual, "vec3 t = vec3(m[1][1] * m[2][2] - m[1][2] * m[2][1], m[1][2] * m[2][0] - m[1][0] * m[2][2], m[1][0] * m[2][1] - m[1][1] * m[2][0]);");
statement("return mat3(t[0], "
"m[0][2] * m[2][1] - m[0][1] * m[2][2], "
"m[0][1] * m[1][2] - m[0][2] * m[1][1], "
"t[1], "
"m[0][0] * m[2][2] - m[0][2] * m[2][0], "
"m[0][2] * m[1][0] - m[0][0] * m[1][2], "
"t[2], "
"m[0][1] * m[2][0] - m[0][0] * m[2][1], "
"m[0][0] * m[1][1] - m[0][1] * m[1][0]) "
"* (1.0 / dot(m[0], t));");
end_scope();
statement("");
}
if (polyfills & PolyfillMatrixInverse4x4)
{
statement(qual, "mat4 spvInverse", suffix, "(", qual, "mat4 m)");
begin_scope();
statement(qual, "vec4 t = vec4("
"m[2][1] * m[3][2] * m[1][3] - m[3][1] * m[2][2] * m[1][3] + m[3][1] * m[1][2] * m[2][3] - m[1][1] * m[3][2] * m[2][3] - m[2][1] * m[1][2] * m[3][3] + m[1][1] * m[2][2] * m[3][3], "
"m[3][0] * m[2][2] * m[1][3] - m[2][0] * m[3][2] * m[1][3] - m[3][0] * m[1][2] * m[2][3] + m[1][0] * m[3][2] * m[2][3] + m[2][0] * m[1][2] * m[3][3] - m[1][0] * m[2][2] * m[3][3], "
"m[2][0] * m[3][1] * m[1][3] - m[3][0] * m[2][1] * m[1][3] + m[3][0] * m[1][1] * m[2][3] - m[1][0] * m[3][1] * m[2][3] - m[2][0] * m[1][1] * m[3][3] + m[1][0] * m[2][1] * m[3][3], "
"m[3][0] * m[2][1] * m[1][2] - m[2][0] * m[3][1] * m[1][2] - m[3][0] * m[1][1] * m[2][2] + m[1][0] * m[3][1] * m[2][2] + m[2][0] * m[1][1] * m[3][2] - m[1][0] * m[2][1] * m[3][2]);");
statement("return mat4("
"t[0], "
"m[3][1] * m[2][2] * m[0][3] - m[2][1] * m[3][2] * m[0][3] - m[3][1] * m[0][2] * m[2][3] + m[0][1] * m[3][2] * m[2][3] + m[2][1] * m[0][2] * m[3][3] - m[0][1] * m[2][2] * m[3][3], "
"m[1][1] * m[3][2] * m[0][3] - m[3][1] * m[1][2] * m[0][3] + m[3][1] * m[0][2] * m[1][3] - m[0][1] * m[3][2] * m[1][3] - m[1][1] * m[0][2] * m[3][3] + m[0][1] * m[1][2] * m[3][3], "
"m[2][1] * m[1][2] * m[0][3] - m[1][1] * m[2][2] * m[0][3] - m[2][1] * m[0][2] * m[1][3] + m[0][1] * m[2][2] * m[1][3] + m[1][1] * m[0][2] * m[2][3] - m[0][1] * m[1][2] * m[2][3], "
"t[1], "
"m[2][0] * m[3][2] * m[0][3] - m[3][0] * m[2][2] * m[0][3] + m[3][0] * m[0][2] * m[2][3] - m[0][0] * m[3][2] * m[2][3] - m[2][0] * m[0][2] * m[3][3] + m[0][0] * m[2][2] * m[3][3], "
"m[3][0] * m[1][2] * m[0][3] - m[1][0] * m[3][2] * m[0][3] - m[3][0] * m[0][2] * m[1][3] + m[0][0] * m[3][2] * m[1][3] + m[1][0] * m[0][2] * m[3][3] - m[0][0] * m[1][2] * m[3][3], "
"m[1][0] * m[2][2] * m[0][3] - m[2][0] * m[1][2] * m[0][3] + m[2][0] * m[0][2] * m[1][3] - m[0][0] * m[2][2] * m[1][3] - m[1][0] * m[0][2] * m[2][3] + m[0][0] * m[1][2] * m[2][3], "
"t[2], "
"m[3][0] * m[2][1] * m[0][3] - m[2][0] * m[3][1] * m[0][3] - m[3][0] * m[0][1] * m[2][3] + m[0][0] * m[3][1] * m[2][3] + m[2][0] * m[0][1] * m[3][3] - m[0][0] * m[2][1] * m[3][3], "
"m[1][0] * m[3][1] * m[0][3] - m[3][0] * m[1][1] * m[0][3] + m[3][0] * m[0][1] * m[1][3] - m[0][0] * m[3][1] * m[1][3] - m[1][0] * m[0][1] * m[3][3] + m[0][0] * m[1][1] * m[3][3], "
"m[2][0] * m[1][1] * m[0][3] - m[1][0] * m[2][1] * m[0][3] - m[2][0] * m[0][1] * m[1][3] + m[0][0] * m[2][1] * m[1][3] + m[1][0] * m[0][1] * m[2][3] - m[0][0] * m[1][1] * m[2][3], "
"t[3], "
"m[2][0] * m[3][1] * m[0][2] - m[3][0] * m[2][1] * m[0][2] + m[3][0] * m[0][1] * m[2][2] - m[0][0] * m[3][1] * m[2][2] - m[2][0] * m[0][1] * m[3][2] + m[0][0] * m[2][1] * m[3][2], "
"m[3][0] * m[1][1] * m[0][2] - m[1][0] * m[3][1] * m[0][2] - m[3][0] * m[0][1] * m[1][2] + m[0][0] * m[3][1] * m[1][2] + m[1][0] * m[0][1] * m[3][2] - m[0][0] * m[1][1] * m[3][2], "
"m[1][0] * m[2][1] * m[0][2] - m[2][0] * m[1][1] * m[0][2] + m[2][0] * m[0][1] * m[1][2] - m[0][0] * m[2][1] * m[1][2] - m[1][0] * m[0][1] * m[2][2] + m[0][0] * m[1][1] * m[2][2]) "
"* (1.0 / dot(m[0], t));");
end_scope();
statement("");
}
GLSL: Use SPIR-V intrinsics for N{Min,Max,Clamp}. When targeting Vulkan semantics, we should emit code that is actually readable. Also, make sure to use plain F{Min,Max,Clamp} on HLSL. HLSL has NaN-aware semantics by default.
2024-05-21 14:52:51 +00:00
if (!relaxed)
{
static const Polyfill polys[3][3] = {
{ PolyfillNMin16, PolyfillNMin32, PolyfillNMin64 },
{ PolyfillNMax16, PolyfillNMax32, PolyfillNMax64 },
{ PolyfillNClamp16, PolyfillNClamp32, PolyfillNClamp64 },
};
static const GLSLstd450 glsl_ops[] = { GLSLstd450NMin, GLSLstd450NMax, GLSLstd450NClamp };
static const char *spv_ops[] = { "spvNMin", "spvNMax", "spvNClamp" };
bool has_poly = false;
for (uint32_t i = 0; i < 3; i++)
{
for (uint32_t j = 0; j < 3; j++)
{
if ((polyfills & polys[i][j]) == 0)
continue;
const char *types[3][4] = {
{ "float16_t", "f16vec2", "f16vec3", "f16vec4" },
{ "float", "vec2", "vec3", "vec4" },
{ "double", "dvec2", "dvec3", "dvec4" },
};
for (uint32_t k = 0; k < 4; k++)
{
auto *type = types[j][k];
if (i < 2)
{
statement("spirv_instruction(set = \"GLSL.std.450\", id = ", glsl_ops[i], ") ",
type, " ", spv_ops[i], "(", type, ", ", type, ");");
}
else
{
statement("spirv_instruction(set = \"GLSL.std.450\", id = ", glsl_ops[i], ") ",
type, " ", spv_ops[i], "(", type, ", ", type, ", ", type, ");");
}
has_poly = true;
}
}
}
if (has_poly)
statement("");
}
else
{
// Mediump intrinsics don't work correctly, so wrap the intrinsic in an outer shell that ensures mediump
// propagation.
static const Polyfill polys[3][3] = {
{ PolyfillNMin16, PolyfillNMin32, PolyfillNMin64 },
{ PolyfillNMax16, PolyfillNMax32, PolyfillNMax64 },
{ PolyfillNClamp16, PolyfillNClamp32, PolyfillNClamp64 },
};
static const char *spv_ops[] = { "spvNMin", "spvNMax", "spvNClamp" };
for (uint32_t i = 0; i < 3; i++)
{
for (uint32_t j = 0; j < 3; j++)
{
if ((polyfills & polys[i][j]) == 0)
continue;
const char *types[3][4] = {
{ "float16_t", "f16vec2", "f16vec3", "f16vec4" },
{ "float", "vec2", "vec3", "vec4" },
{ "double", "dvec2", "dvec3", "dvec4" },
};
for (uint32_t k = 0; k < 4; k++)
{
auto *type = types[j][k];
if (i < 2)
{
statement("mediump ", type, " ", spv_ops[i], "Relaxed(",
"mediump ", type, " a, mediump ", type, " b)");
begin_scope();
statement("mediump ", type, " res = ", spv_ops[i], "(a, b);");
statement("return res;");
end_scope();
statement("");
}
else
{
statement("mediump ", type, " ", spv_ops[i], "Relaxed(",
"mediump ", type, " a, mediump ", type, " b, mediump ", type, " c)");
begin_scope();
statement("mediump ", type, " res = ", spv_ops[i], "(a, b, c);");
statement("return res;");
end_scope();
statement("");
}
}
}
}
}
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
// Returns a string representation of the ID, usable as a function arg.
// Default is to simply return the expression representation fo the arg ID.
// Subclasses may override to modify the return value.
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
string CompilerGLSL::to_func_call_arg(const SPIRFunction::Parameter &, uint32_t id)
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
{
MSL: Fix naming issue of aliased global variables. When the name of an alias global variable collides with a global declaration, MSL would emit inconsistent names, sometimes with the naming fix, sometimes without, because names were being tracked in two separate meta blocks. Fix this by always redirecting parameter naming to the original base variable as necessary.
2018-08-27 07:59:55 +00:00
// Make sure that we use the name of the original variable, and not the parameter alias.
uint32_t name_id = id;
auto *var = maybe_get<SPIRVariable>(id);
if (var && var->basevariable)
name_id = var->basevariable;
return to_expression(name_id);
MSL support textures and samplers as function args. Add automatic sampler func arg when passing SampledImage type. Pass texture and sampler in thread address space.
2016-07-07 00:30:47 +00:00
}
Add more scenarios where we can guarantee forward progress. The patterns where we force temporary due to invalid/overused expression -> recompile should be seen as making forward progress, and there are very rare scenarios where these recompiles can cascade into many loops. Refactor this style of logic into a new function which is equivalent to handle_invalid_expression().
2022-02-16 11:12:58 +00:00
void CompilerGLSL::force_temporary_and_recompile(uint32_t id)
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
{
Rework how loop iteration counts are validated. Introduces an idea of a recompilation making forward progress. There are some extreme edge cases where we need more than 3 loops, but only allow this in specific circumstances where we can reason about forward progress being made.
2022-01-17 13:12:01 +00:00
auto res = forced_temporaries.insert(id);
// Forcing new temporaries guarantees forward progress.
if (res.second)
force_recompile_guarantee_forward_progress();
else
force_recompile();
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
}
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
uint32_t CompilerGLSL::consume_temporary_in_precision_context(uint32_t type_id, uint32_t id, Options::Precision precision)
{
// Constants do not have innate precision.
GLSL: Do not analyze precision for Undef variables. Undefs won't have a chance to emit aliases, and any expression depending on Undef will be garbage either way.
2022-05-13 10:14:56 +00:00
auto handle_type = ir.ids[id].get_type();
if (handle_type == TypeConstant || handle_type == TypeConstantOp || handle_type == TypeUndef)
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
return id;
// Ignore anything that isn't 32-bit values.
auto &type = get<SPIRType>(type_id);
if (type.pointer)
return id;
if (type.basetype != SPIRType::Float && type.basetype != SPIRType::UInt && type.basetype != SPIRType::Int)
return id;
if (precision == Options::DontCare)
{
// If precision is consumed as don't care (operations only consisting of constants),
// we need to bind the expression to a temporary,
// otherwise we have no way of controlling the precision later.
auto itr = forced_temporaries.insert(id);
if (itr.second)
force_recompile_guarantee_forward_progress();
return id;
}
auto current_precision = has_decoration(id, DecorationRelaxedPrecision) ? Options::Mediump : Options::Highp;
if (current_precision == precision)
return id;
auto itr = temporary_to_mirror_precision_alias.find(id);
if (itr == temporary_to_mirror_precision_alias.end())
{
uint32_t alias_id = ir.increase_bound_by(1);
auto &m = ir.meta[alias_id];
if (auto *input_m = ir.find_meta(id))
m = *input_m;
const char *prefix;
if (precision == Options::Mediump)
{
set_decoration(alias_id, DecorationRelaxedPrecision);
prefix = "mp_copy_";
}
else
{
unset_decoration(alias_id, DecorationRelaxedPrecision);
prefix = "hp_copy_";
}
auto alias_name = join(prefix, to_name(id));
ParsedIR::sanitize_underscores(alias_name);
set_name(alias_id, alias_name);
emit_op(type_id, alias_id, to_expression(id), true);
temporary_to_mirror_precision_alias[id] = alias_id;
forced_temporaries.insert(id);
forced_temporaries.insert(alias_id);
force_recompile_guarantee_forward_progress();
id = alias_id;
}
else
{
id = itr->second;
}
return id;
}
Add more scenarios where we can guarantee forward progress. The patterns where we force temporary due to invalid/overused expression -> recompile should be seen as making forward progress, and there are very rare scenarios where these recompiles can cascade into many loops. Refactor this style of logic into a new function which is equivalent to handle_invalid_expression().
2022-02-16 11:12:58 +00:00
void CompilerGLSL::handle_invalid_expression(uint32_t id)
{
// We tried to read an invalidated expression.
// This means we need another pass at compilation, but next time,
// force temporary variables so that they cannot be invalidated.
force_temporary_and_recompile(id);
Attempt more optimal codegen for OpCompositeInsert. Speculate that we can modify the SSA value in-place. As long as it is not used after the modify, this is fine. Also need to make sure we don't attempt to RMW something that is impossible to modify.
2022-05-18 10:26:20 +00:00
// If the invalid expression happened as a result of a CompositeInsert
// overwrite, we must block this from happening next iteration.
if (composite_insert_overwritten.count(id))
block_composite_insert_overwrite.insert(id);
Add more scenarios where we can guarantee forward progress. The patterns where we force temporary due to invalid/overused expression -> recompile should be seen as making forward progress, and there are very rare scenarios where these recompiles can cascade into many loops. Refactor this style of logic into a new function which is equivalent to handle_invalid_expression().
2022-02-16 11:12:58 +00:00
}
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
// Converts the format of the current expression from packed to unpacked,
// by wrapping the expression in a constructor of the appropriate type.
// GLSL does not support packed formats, so simply return the expression.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
// Subclasses that do will override.
Pass down row-major state to unpacking functions.
2019-07-19 11:03:08 +00:00
string CompilerGLSL::unpack_expression_type(string expr_str, const SPIRType &, uint32_t, bool, bool)
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
{
return expr_str;
}
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
// Sometimes we proactively enclosed an expression where it turns out we might have not needed it after all.
void CompilerGLSL::strip_enclosed_expression(string &expr)
{
if (expr.size() < 2 || expr.front() != '(' || expr.back() != ')')
return;
// Have to make sure that our first and last parens actually enclose everything inside it.
uint32_t paren_count = 0;
for (auto &c : expr)
{
if (c == '(')
paren_count++;
else if (c == ')')
{
paren_count--;
// If we hit 0 and this is not the final char, our first and final parens actually don't
// enclose the expression, and we cannot strip, e.g.: (a + b) * (c + d).
if (paren_count == 0 && &c != &expr.back())
return;
}
}
Fix compilation on some old C++11 standard libraries.
2017-01-18 22:22:19 +00:00
expr.erase(expr.size() - 1, 1);
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
expr.erase(begin(expr));
}
GLSL: Fix expression reorder bug with legacy FMA fallback.
2023-03-30 14:51:05 +00:00
bool CompilerGLSL::needs_enclose_expression(const std::string &expr)
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
{
bool need_parens = false;
Fix unary enclosures.
2017-07-24 08:17:19 +00:00
// If the expression starts with a unary we need to enclose to deal with cases where we have back-to-back
// unary expressions.
if (!expr.empty())
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
{
Fix unary enclosures.
2017-07-24 08:17:19 +00:00
auto c = expr.front();
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
if (c == '-' || c == '+' || c == '!' || c == '~' || c == '&' || c == '*')
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
need_parens = true;
Fix unary enclosures.
2017-07-24 08:17:19 +00:00
}
Minor optimization of enclose_expression.
2017-07-25 16:25:03 +00:00
if (!need_parens)
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
{
Minor optimization of enclose_expression.
2017-07-25 16:25:03 +00:00
uint32_t paren_count = 0;
for (auto c : expr)
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
{
Don't need to enclose expression for arrays.
2018-07-05 12:09:25 +00:00
if (c == '(' || c == '[')
Minor optimization of enclose_expression.
2017-07-25 16:25:03 +00:00
paren_count++;
Don't need to enclose expression for arrays.
2018-07-05 12:09:25 +00:00
else if (c == ')' || c == ']')
Minor optimization of enclose_expression.
2017-07-25 16:25:03 +00:00
{
assert(paren_count);
paren_count--;
}
else if (c == ' ' && paren_count == 0)
{
need_parens = true;
break;
}
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
}
Minor optimization of enclose_expression.
2017-07-25 16:25:03 +00:00
assert(paren_count == 0);
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
}
GLSL: Fix expression reorder bug with legacy FMA fallback.
2023-03-30 14:51:05 +00:00
return need_parens;
}
string CompilerGLSL::enclose_expression(const string &expr)
{
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
// If this expression contains any spaces which are not enclosed by parentheses,
// we need to enclose it so we can treat the whole string as an expression.
// This happens when two expressions have been part of a binary op earlier.
GLSL: Fix expression reorder bug with legacy FMA fallback.
2023-03-30 14:51:05 +00:00
if (needs_enclose_expression(expr))
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
return join('(', expr, ')');
else
return expr;
}
Fix GCC 4.x warning.
2019-04-26 11:09:54 +00:00
string CompilerGLSL::dereference_expression(const SPIRType &expr_type, const std::string &expr)
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
{
// If this expression starts with an address-of operator ('&'), then
// just return the part after the operator.
// TODO: Strip parens if unnecessary?
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
if (expr.front() == '&')
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
return expr.substr(1);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
else if (backend.native_pointers)
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
return join('*', expr);
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
else if (is_physical_pointer(expr_type) && !is_physical_pointer_to_buffer_block(expr_type))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
return join(enclose_expression(expr), ".value");
else
return expr;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
}
string CompilerGLSL::address_of_expression(const std::string &expr)
{
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
if (expr.size() > 3 && expr[0] == '(' && expr[1] == '*' && expr.back() == ')')
{
// If we have an expression which looks like (*foo), taking the address of it is the same as stripping
// the first two and last characters. We might have to enclose the expression.
// This doesn't work for cases like (*foo + 10),
// but this is an r-value expression which we cannot take the address of anyways.
return enclose_expression(expr.substr(2, expr.size() - 3));
}
else if (expr.front() == '*')
{
// If this expression starts with a dereference operator ('*'), then
// just return the part after the operator.
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
return expr.substr(1);
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
else
MSL: Implement OpArrayLength. This gets rather complicated because MSL does not support OpArrayLength natively. We need to pass down a buffer which contains buffer sizes, and we compute the array length on-demand. Support both discrete descriptors as well as argument buffers.
2019-05-27 09:59:29 +00:00
return join('&', enclose_expression(expr));
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
}
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
// Just like to_expression except that we enclose the expression inside parentheses if needed.
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
string CompilerGLSL::to_enclosed_expression(uint32_t id, bool register_expression_read)
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
{
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
return enclose_expression(to_expression(id, register_expression_read));
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
}
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
// Used explicitly when we want to read a row-major expression, but without any transpose shenanigans.
// need_transpose must be forced to false.
string CompilerGLSL::to_unpacked_row_major_matrix_expression(uint32_t id)
{
return unpack_expression_type(to_expression(id), expression_type(id),
get_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID),
has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked), true);
}
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
string CompilerGLSL::to_unpacked_expression(uint32_t id, bool register_expression_read)
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
{
Do not unpack transposed matrices.
2018-06-12 07:36:13 +00:00
// If we need to transpose, it will also take care of unpacking rules.
auto *e = maybe_get<SPIRExpression>(id);
bool need_transpose = e && e->need_transpose;
Fix unpacking of packed but not remapped types on load.
2019-07-19 12:50:35 +00:00
bool is_remapped = has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID);
bool is_packed = has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked);
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
Fix unpacking of packed but not remapped types on load.
2019-07-19 12:50:35 +00:00
if (!need_transpose && (is_remapped || is_packed))
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
{
Look at pointee type when unpacking expressions. We might be unpacking in OpLoad, so don't want any pointer types from access chains creeping in.
2019-07-23 15:06:37 +00:00
return unpack_expression_type(to_expression(id, register_expression_read),
get_pointee_type(expression_type_id(id)),
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
get_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID),
Pass down row-major state to unpacking functions.
2019-07-19 11:03:08 +00:00
has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked), false);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
}
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
else
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
return to_expression(id, register_expression_read);
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
}
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
string CompilerGLSL::to_enclosed_unpacked_expression(uint32_t id, bool register_expression_read)
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
{
MSL: Support more usecases for unpacked vectors. Additional usecases include array and vector indexing, variable declarations, loop initializers, function return values, switch statement evaluations, and various specialized MSL operations. Ultimately, we might consider refactoring CompilerMSL::to_expression() to always take into consideration possible unpacking behavior. Refactor CompilerGLSL::to_enclosed_unpacked_expression() for conciseness and consistency with similar functionality.
2021-10-21 20:11:33 +00:00
return enclose_expression(to_unpacked_expression(id, register_expression_read));
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
string CompilerGLSL::to_dereferenced_expression(uint32_t id, bool register_expression_read)
{
auto &type = expression_type(id);
MSL: Clean up some obsolete use of type.pointer.
2024-06-19 12:23:49 +00:00
if (is_pointer(type) && should_dereference(id))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
return dereference_expression(type, to_enclosed_expression(id, register_expression_read));
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
else
return to_expression(id, register_expression_read);
}
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
string CompilerGLSL::to_pointer_expression(uint32_t id, bool register_expression_read)
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
{
auto &type = expression_type(id);
MSL: Clean up some obsolete use of type.pointer.
2024-06-19 12:23:49 +00:00
if (is_pointer(type) && expression_is_lvalue(id) && !should_dereference(id))
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
return address_of_expression(to_enclosed_expression(id, register_expression_read));
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
else
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
return to_unpacked_expression(id, register_expression_read);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
}
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
string CompilerGLSL::to_enclosed_pointer_expression(uint32_t id, bool register_expression_read)
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
{
auto &type = expression_type(id);
MSL: Clean up some obsolete use of type.pointer.
2024-06-19 12:23:49 +00:00
if (is_pointer(type) && expression_is_lvalue(id) && !should_dereference(id))
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
return address_of_expression(to_enclosed_expression(id, register_expression_read));
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
else
Need to know the original packed type when unpacking loads.
2019-01-17 10:39:16 +00:00
return to_enclosed_unpacked_expression(id, register_expression_read);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
}
Deal with packed expressions in more scenarios. Make a new "to_extract_component_expression" helper.
2018-05-25 08:56:27 +00:00
string CompilerGLSL::to_extract_component_expression(uint32_t id, uint32_t index)
{
auto expr = to_enclosed_expression(id);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked))
Deal with packed expressions in more scenarios. Make a new "to_extract_component_expression" helper.
2018-05-25 08:56:27 +00:00
return join(expr, "[", index, "]");
else
return join(expr, ".", index_to_swizzle(index));
}
Deal better with CompositeExtract from constant composite. There is no good reason for applications to emit this kind of code, but some do. Special case this scenario.
2021-01-22 11:17:05 +00:00
string CompilerGLSL::to_extract_constant_composite_expression(uint32_t result_type, const SPIRConstant &c,
const uint32_t *chain, uint32_t length)
{
// It is kinda silly if application actually enter this path since they know the constant up front.
// It is useful here to extract the plain constant directly.
SPIRConstant tmp;
tmp.constant_type = result_type;
auto &composite_type = get<SPIRType>(c.constant_type);
assert(composite_type.basetype != SPIRType::Struct && composite_type.array.empty());
assert(!c.specialization);
if (is_matrix(composite_type))
{
if (length == 2)
{
tmp.m.c[0].vecsize = 1;
tmp.m.columns = 1;
tmp.m.c[0].r[0] = c.m.c[chain[0]].r[chain[1]];
}
else
{
assert(length == 1);
tmp.m.c[0].vecsize = composite_type.vecsize;
tmp.m.columns = 1;
tmp.m.c[0] = c.m.c[chain[0]];
}
}
else
{
assert(length == 1);
tmp.m.c[0].vecsize = 1;
tmp.m.columns = 1;
tmp.m.c[0].r[0] = c.m.c[0].r[chain[0]];
}
return constant_expression(tmp);
}
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
string CompilerGLSL::to_rerolled_array_expression(const SPIRType &parent_type,
const string &base_expr, const SPIRType &type)
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
{
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
bool remapped_boolean = parent_type.basetype == SPIRType::Struct &&
type.basetype == SPIRType::Boolean &&
backend.boolean_in_struct_remapped_type != SPIRType::Boolean;
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType tmp_type { OpNop };
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
if (remapped_boolean)
MSL: Handle stores to struct bool[].
2023-06-06 11:55:29 +00:00
{
tmp_type = get<SPIRType>(type.parent_type);
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
tmp_type.basetype = backend.boolean_in_struct_remapped_type;
MSL: Handle stores to struct bool[].
2023-06-06 11:55:29 +00:00
}
MSL: Handle more complex array copy scenarios with bool <-> short.
2023-06-06 13:05:56 +00:00
else if (type.basetype == SPIRType::Boolean && backend.boolean_in_struct_remapped_type != SPIRType::Boolean)
{
// It's possible that we have an r-value expression that was OpLoaded from a struct.
// We have to reroll this and explicitly cast the input to bool, because the r-value is short.
tmp_type = get<SPIRType>(type.parent_type);
remapped_boolean = true;
}
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
uint32_t size = to_array_size_literal(type);
auto &parent = get<SPIRType>(type.parent_type);
string expr = "{ ";
for (uint32_t i = 0; i < size; i++)
{
auto subexpr = join(base_expr, "[", convert_to_string(i), "]");
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
if (!is_array(parent))
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
{
if (remapped_boolean)
subexpr = join(type_to_glsl(tmp_type), "(", subexpr, ")");
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
expr += subexpr;
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
}
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
else
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
expr += to_rerolled_array_expression(parent_type, subexpr, parent);
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
if (i + 1 < size)
expr += ", ";
}
expr += " }";
return expr;
}
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
string CompilerGLSL::to_composite_constructor_expression(const SPIRType &parent_type, uint32_t id, bool block_like_type)
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
{
auto &type = expression_type(id);
MSL: Improve handling of array types in buffer objects. When loading and storing array types which belong to buffer objects, we need to treat these values as not being value types. Also, need to handle array load/store from/to more address space combinations.
2020-06-18 09:37:24 +00:00
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
bool reroll_array = false;
bool remapped_boolean = parent_type.basetype == SPIRType::Struct &&
type.basetype == SPIRType::Boolean &&
backend.boolean_in_struct_remapped_type != SPIRType::Boolean;
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
if (is_array(type))
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
{
reroll_array = !backend.array_is_value_type ||
(block_like_type && !backend.array_is_value_type_in_buffer_blocks);
if (remapped_boolean)
{
// Forced to reroll if we have to change bool[] to short[].
reroll_array = true;
}
}
MSL: Improve handling of array types in buffer objects. When loading and storing array types which belong to buffer objects, we need to treat these values as not being value types. Also, need to handle array load/store from/to more address space combinations.
2020-06-18 09:37:24 +00:00
if (reroll_array)
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
{
// For this case, we need to "re-roll" an array initializer from a temporary.
// We cannot simply pass the array directly, since it decays to a pointer and it cannot
// participate in a struct initializer. E.g.
// float arr[2] = { 1.0, 2.0 };
// Foo foo = { arr }; must be transformed to
// Foo foo = { { arr[0], arr[1] } };
// The array sizes cannot be deduced from specialization constants since we cannot use any loops.
// We're only triggering one read of the array expression, but this is fine since arrays have to be declared
// as temporaries anyways.
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
return to_rerolled_array_expression(parent_type, to_enclosed_expression(id), type);
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
}
else
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
{
auto expr = to_unpacked_expression(id);
if (remapped_boolean)
{
auto tmp_type = type;
tmp_type.basetype = backend.boolean_in_struct_remapped_type;
expr = join(type_to_glsl(tmp_type), "(", expr, ")");
}
return expr;
}
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
}
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
string CompilerGLSL::to_non_uniform_aware_expression(uint32_t id)
{
string expr = to_expression(id);
if (has_decoration(id, DecorationNonUniform))
convert_non_uniform_expression(expr, id);
return expr;
}
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
string CompilerGLSL::to_expression(uint32_t id, bool register_expression_read)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto itr = invalid_expressions.find(id);
if (itr != end(invalid_expressions))
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
handle_invalid_expression(id);
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (ir.ids[id].get_type() == TypeExpression)
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
{
// We might have a more complex chain of dependencies.
// A possible scenario is that we
//
// %1 = OpLoad
// %2 = OpDoSomething %1 %1. here %2 will have a dependency on %1.
// %3 = OpDoSomethingAgain %2 %2. Here %3 will lose the link to %1 since we don't propagate the dependencies like that.
// OpStore %1 %foo // Here we can invalidate %1, and hence all expressions which depend on %1. Only %2 will know since it's part of invalid_expressions.
// %4 = OpDoSomethingAnotherTime %3 %3 // If we forward all expressions we will see %1 expression after store, not before.
//
// However, we can propagate up a list of depended expressions when we used %2, so we can check if %2 is invalid when reading %3 after the store,
// and see that we should not forward reads of the original variable.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &expr = get<SPIRExpression>(id);
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
for (uint32_t dep : expr.expression_dependencies)
if (invalid_expressions.find(dep) != end(invalid_expressions))
handle_invalid_expression(dep);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
if (register_expression_read)
track_expression_read(id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
switch (ir.ids[id].get_type())
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
case TypeExpression:
{
auto &e = get<SPIRExpression>(id);
if (e.base_expression)
Fix code generated from optimized OpCompositeExtract.
2016-12-06 16:19:34 +00:00
return to_enclosed_expression(e.base_expression) + e.expression;
Deal correctly with non-forwarded packed loads. Need to unpack the expression if we're not forwarding.
2019-07-23 14:25:19 +00:00
else if (e.need_transpose)
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
{
Remove obsolete matrix workaround code.
2019-07-22 14:27:47 +00:00
// This should not be reached for access chains, since we always deal explicitly with transpose state
// when consuming an access chain expression.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
uint32_t physical_type_id = get_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID);
bool is_packed = has_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked);
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
bool relaxed = has_decoration(id, DecorationRelaxedPrecision);
Run format_all.sh.
2019-07-23 10:23:41 +00:00
return convert_row_major_matrix(e.expression, get<SPIRType>(e.expression_type), physical_type_id,
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
is_packed, relaxed);
CompilerMSL support smaller offsets for 3-row row-major matrices. Support MSL typedefs to declare 3-row row-major matrices as 3-column matrices. Allow those matrices to be decorated as packed. Support transposing those matrices when used. Modify how member alignments are calculated.
2018-02-11 21:52:57 +00:00
}
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
else if (flattened_structs.count(id))
{
return load_flattened_struct(e.expression, get<SPIRType>(e.expression_type));
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Handle exponential explosion of code-gen during first phase of compile. Certain patterns with OpVectorShuffle (and probably others) will cascade to so large, that they can cause OOM. After we have observed force_recompile, don't spend unnecessary memory emitting code which will never be used.
2018-01-15 09:26:12 +00:00
{
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
if (is_forcing_recompilation())
Handle exponential explosion of code-gen during first phase of compile. Certain patterns with OpVectorShuffle (and probably others) will cascade to so large, that they can cause OOM. After we have observed force_recompile, don't spend unnecessary memory emitting code which will never be used.
2018-01-15 09:26:12 +00:00
{
// During first compilation phase, certain expression patterns can trigger exponential growth of memory.
// Avoid this by returning dummy expressions during this phase.
// Do not use empty expressions here, because those are sentinels for other cases.
return "_";
}
else
return e.expression;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
case TypeConstant:
Emit spec constants directly with Vulkan semantics. Emit an actual spec constant declaration in Vulkan instead of resolving the constant.
2016-10-03 10:52:56 +00:00
{
auto &c = get<SPIRConstant>(id);
Do not declare constant composites inline in HLSL. Move arrays and structs out to their own global static constants. Also, replace illegal names in HLSL as well.
2018-02-02 09:10:17 +00:00
auto &type = get<SPIRType>(c.constant_type);
Correctly resolve constant expressions for WorkGroupSize.
2017-09-28 10:34:48 +00:00
// WorkGroupSize may be a constant.
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
if (has_decoration(c.self, DecorationBuiltIn))
return builtin_to_glsl(BuiltIn(get_decoration(c.self, DecorationBuiltIn)), StorageClassGeneric);
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
else if (c.specialization)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
{
if (backend.workgroup_size_is_hidden)
{
int wg_index = get_constant_mapping_to_workgroup_component(c);
if (wg_index >= 0)
{
auto wg_size = join(builtin_to_glsl(BuiltInWorkgroupSize, StorageClassInput), vector_swizzle(1, wg_index));
if (type.basetype != SPIRType::UInt)
wg_size = bitcast_expression(type, SPIRType::UInt, wg_size);
return wg_size;
}
}
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
if (expression_is_forwarded(id))
return constant_expression(c);
Emit spec constants directly with Vulkan semantics. Emit an actual spec constant declaration in Vulkan instead of resolving the constant.
2016-10-03 10:52:56 +00:00
return to_name(id);
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
}
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
else if (c.is_used_as_lut)
return to_name(id);
Do not declare constant composites inline in HLSL. Move arrays and structs out to their own global static constants. Also, replace illegal names in HLSL as well.
2018-02-02 09:10:17 +00:00
else if (type.basetype == SPIRType::Struct && !backend.can_declare_struct_inline)
return to_name(id);
else if (!type.array.empty() && !backend.can_declare_arrays_inline)
return to_name(id);
Emit spec constants directly with Vulkan semantics. Emit an actual spec constant declaration in Vulkan instead of resolving the constant.
2016-10-03 10:52:56 +00:00
else
return constant_expression(c);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
case TypeConstantOp:
Run format_all.sh.
2018-11-01 10:23:33 +00:00
return to_name(id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case TypeVariable:
{
auto &var = get<SPIRVariable>(id);
Add directed test for for-loop-init.
2016-12-16 11:43:12 +00:00
// If we try to use a loop variable before the loop header, we have to redirect it to the static expression,
// the variable has not been declared yet.
if (var.statically_assigned || (var.loop_variable && !var.loop_variable_enable))
Handle early reads from loop variables with initializers. Need to consider that static_expression can be 0. Fallback as necessary. Also need to clear the static expression.
2022-04-28 12:36:53 +00:00
{
// We might try to load from a loop variable before it has been initialized.
// Prefer static expression and fallback to initializer.
if (var.static_expression)
return to_expression(var.static_expression);
else if (var.initializer)
return to_expression(var.initializer);
else
{
// We cannot declare the variable yet, so have to fake it.
uint32_t undef_id = ir.increase_bound_by(1);
return emit_uninitialized_temporary_expression(get_variable_data_type_id(var), undef_id).expression;
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (var.deferred_declaration)
{
var.deferred_declaration = false;
return variable_decl(var);
}
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
else if (flattened_structs.count(id))
{
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
return load_flattened_struct(to_name(id), get<SPIRType>(var.basetype));
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &dec = ir.meta[var.self].decoration;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (dec.builtin)
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
return builtin_to_glsl(dec.builtin_type, var.storage);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
return to_name(id);
}
}
HLSL: Basic support for separate image/samplers.
2017-04-25 08:44:55 +00:00
case TypeCombinedImageSampler:
// This type should never be taken the expression of directly.
// The intention is that texture sampling functions will extract the image and samplers
// separately and take their expressions as needed.
// GLSL does not use this type because OpSampledImage immediately creates a combined image sampler
// expression ala sampler2D(texture, sampler).
SPIRV_CROSS_THROW("Combined image samplers have no default expression representation.");
Emit flattened loads and stores.
2017-08-10 15:12:48 +00:00
case TypeAccessChain:
// We cannot express this type. They only have meaning in other OpAccessChains, OpStore or OpLoad.
SPIRV_CROSS_THROW("Access chains have no default expression representation.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
return to_name(id);
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
SmallVector<ConstantID> CompilerGLSL::get_composite_constant_ids(ConstantID const_id)
{
if (auto *constant = maybe_get<SPIRConstant>(const_id))
{
const auto &type = get<SPIRType>(constant->constant_type);
if (is_array(type) || type.basetype == SPIRType::Struct)
return constant->subconstants;
if (is_matrix(type))
Fix GCC5 build.
2023-01-05 11:24:02 +00:00
return SmallVector<ConstantID>(constant->m.id);
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
if (is_vector(type))
Fix GCC5 build.
2023-01-05 11:24:02 +00:00
return SmallVector<ConstantID>(constant->m.c[0].id);
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
SPIRV_CROSS_THROW("Unexpected scalar constant!");
}
if (!const_composite_insert_ids.count(const_id))
SPIRV_CROSS_THROW("Unimplemented for this OpSpecConstantOp!");
return const_composite_insert_ids[const_id];
}
void CompilerGLSL::fill_composite_constant(SPIRConstant &constant, TypeID type_id,
const SmallVector<ConstantID> &initializers)
{
auto &type = get<SPIRType>(type_id);
constant.specialization = true;
if (is_array(type) || type.basetype == SPIRType::Struct)
{
constant.subconstants = initializers;
}
else if (is_matrix(type))
{
constant.m.columns = type.columns;
for (uint32_t i = 0; i < type.columns; ++i)
{
constant.m.id[i] = initializers[i];
constant.m.c[i].vecsize = type.vecsize;
}
}
else if (is_vector(type))
{
constant.m.c[0].vecsize = type.vecsize;
for (uint32_t i = 0; i < type.vecsize; ++i)
constant.m.c[0].id[i] = initializers[i];
}
else
SPIRV_CROSS_THROW("Unexpected scalar in SpecConstantOp CompositeInsert!");
}
void CompilerGLSL::set_composite_constant(ConstantID const_id, TypeID type_id,
const SmallVector<ConstantID> &initializers)
{
if (maybe_get<SPIRConstantOp>(const_id))
{
const_composite_insert_ids[const_id] = initializers;
return;
}
auto &constant = set<SPIRConstant>(const_id, type_id);
fill_composite_constant(constant, type_id, initializers);
forwarded_temporaries.insert(const_id);
}
TypeID CompilerGLSL::get_composite_member_type(TypeID type_id, uint32_t member_idx)
{
auto &type = get<SPIRType>(type_id);
if (is_array(type))
return type.parent_type;
if (type.basetype == SPIRType::Struct)
return type.member_types[member_idx];
if (is_matrix(type))
return type.parent_type;
if (is_vector(type))
return type.parent_type;
SPIRV_CROSS_THROW("Shouldn't reach lower than vector handling OpSpecConstantOp CompositeInsert!");
}
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
string CompilerGLSL::constant_op_expression(const SPIRConstantOp &cop)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
auto &type = get<SPIRType>(cop.basetype);
bool binary = false;
bool unary = false;
string op;
Be a bit smarter about uint on legacy targets. Allow constants (array sizes for example), but using unsigned opcodes, and unsigned-specific opcodes is a problem.
2018-04-17 12:56:49 +00:00
if (is_legacy() && is_unsigned_opcode(cop.opcode))
SPIRV_CROSS_THROW("Unsigned integers are not supported on legacy targets.");
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
// TODO: Find a clean way to reuse emit_instruction.
switch (cop.opcode)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
case OpSConvert:
case OpUConvert:
case OpFConvert:
op = type_to_glsl_constructor(type);
break;
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define GLSL_BOP(opname, x) \
Run format_all.sh.
2018-06-28 21:00:26 +00:00
case Op##opname: \
binary = true; \
op = x; \
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
break
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define GLSL_UOP(opname, x) \
Run format_all.sh.
2018-06-28 21:00:26 +00:00
case Op##opname: \
unary = true; \
op = x; \
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
break
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UOP(SNegate, "-");
GLSL_UOP(Not, "~");
GLSL_BOP(IAdd, "+");
GLSL_BOP(ISub, "-");
GLSL_BOP(IMul, "*");
GLSL_BOP(SDiv, "/");
GLSL_BOP(UDiv, "/");
GLSL_BOP(UMod, "%");
GLSL_BOP(SMod, "%");
GLSL_BOP(ShiftRightLogical, ">>");
GLSL_BOP(ShiftRightArithmetic, ">>");
GLSL_BOP(ShiftLeftLogical, "<<");
GLSL_BOP(BitwiseOr, "|");
GLSL_BOP(BitwiseXor, "^");
GLSL_BOP(BitwiseAnd, "&");
GLSL_BOP(LogicalOr, "||");
GLSL_BOP(LogicalAnd, "&&");
GLSL_UOP(LogicalNot, "!");
GLSL_BOP(LogicalEqual, "==");
GLSL_BOP(LogicalNotEqual, "!=");
GLSL_BOP(IEqual, "==");
GLSL_BOP(INotEqual, "!=");
GLSL_BOP(ULessThan, "<");
GLSL_BOP(SLessThan, "<");
GLSL_BOP(ULessThanEqual, "<=");
GLSL_BOP(SLessThanEqual, "<=");
GLSL_BOP(UGreaterThan, ">");
GLSL_BOP(SGreaterThan, ">");
GLSL_BOP(UGreaterThanEqual, ">=");
GLSL_BOP(SGreaterThanEqual, ">=");
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
Add support for additional ops in OpSpecConstantOp. MSL: Support op OpQuantizeToF16 in OpSpecConstantOp. All: Support op OpSRem in OpSpecConstantOp.
2021-09-03 22:20:49 +00:00
case OpSRem:
{
uint32_t op0 = cop.arguments[0];
uint32_t op1 = cop.arguments[1];
return join(to_enclosed_expression(op0), " - ", to_enclosed_expression(op1), " * ", "(",
to_enclosed_expression(op0), " / ", to_enclosed_expression(op1), ")");
}
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
case OpSelect:
{
if (cop.arguments.size() < 3)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp.");
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
// This one is pretty annoying. It's triggered from
// uint(bool), int(bool) from spec constants.
// In order to preserve its compile-time constness in Vulkan GLSL,
// we need to reduce the OpSelect expression back to this simplified model.
// If we cannot, fail.
Support ternary expressions in OpSpecConstantOp.
2018-06-25 07:48:17 +00:00
if (to_trivial_mix_op(type, op, cop.arguments[2], cop.arguments[1], cop.arguments[0]))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Support ternary expressions in OpSpecConstantOp.
2018-06-25 07:48:17 +00:00
// Implement as a simple cast down below.
}
else
{
// Implement a ternary and pray the compiler understands it :)
return to_ternary_expression(type, cop.arguments[0], cop.arguments[1], cop.arguments[2]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
break;
}
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
Fix SpecConstantComposite if input is SpecConstantOp.
2018-05-15 09:16:06 +00:00
case OpVectorShuffle:
{
string expr = type_to_glsl_constructor(type);
expr += "(";
uint32_t left_components = expression_type(cop.arguments[0]).vecsize;
string left_arg = to_enclosed_expression(cop.arguments[0]);
string right_arg = to_enclosed_expression(cop.arguments[1]);
for (uint32_t i = 2; i < uint32_t(cop.arguments.size()); i++)
{
uint32_t index = cop.arguments[i];
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
if (index == 0xFFFFFFFF)
{
SPIRConstant c;
c.constant_type = type.parent_type;
assert(type.parent_type != ID(0));
expr += constant_expression(c);
}
else if (index >= left_components)
{
Fix SpecConstantComposite if input is SpecConstantOp.
2018-05-15 09:16:06 +00:00
expr += right_arg + "." + "xyzw"[index - left_components];
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
}
Fix SpecConstantComposite if input is SpecConstantOp.
2018-05-15 09:16:06 +00:00
else
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
{
Fix SpecConstantComposite if input is SpecConstantOp.
2018-05-15 09:16:06 +00:00
expr += left_arg + "." + "xyzw"[index];
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
}
Fix SpecConstantComposite if input is SpecConstantOp.
2018-05-15 09:16:06 +00:00
if (i + 1 < uint32_t(cop.arguments.size()))
expr += ", ";
}
expr += ")";
return expr;
}
case OpCompositeExtract:
{
Run format_all.sh.
2019-01-17 10:29:50 +00:00
auto expr = access_chain_internal(cop.arguments[0], &cop.arguments[1], uint32_t(cop.arguments.size() - 1),
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr);
Fix SpecConstantComposite if input is SpecConstantOp.
2018-05-15 09:16:06 +00:00
return expr;
}
case OpCompositeInsert:
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
{
SmallVector<ConstantID> new_init = get_composite_constant_ids(cop.arguments[1]);
uint32_t idx;
uint32_t target_id = cop.self;
uint32_t target_type_id = cop.basetype;
// We have to drill down to the part we want to modify, and create new
// constants for each containing part.
for (idx = 2; idx < cop.arguments.size() - 1; ++idx)
{
uint32_t new_const = ir.increase_bound_by(1);
uint32_t old_const = new_init[cop.arguments[idx]];
new_init[cop.arguments[idx]] = new_const;
set_composite_constant(target_id, target_type_id, new_init);
new_init = get_composite_constant_ids(old_const);
target_id = new_const;
target_type_id = get_composite_member_type(target_type_id, cop.arguments[idx]);
}
// Now replace the initializer with the one from this instruction.
new_init[cop.arguments[idx]] = cop.arguments[0];
set_composite_constant(target_id, target_type_id, new_init);
SPIRConstant tmp_const(cop.basetype);
fill_composite_constant(tmp_const, cop.basetype, const_composite_insert_ids[cop.self]);
return constant_expression(tmp_const);
}
Fix SpecConstantComposite if input is SpecConstantOp.
2018-05-15 09:16:06 +00:00
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
default:
// Some opcodes are unimplemented here, these are currently not possible to test from glslang.
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Unimplemented spec constant op.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
uint32_t bit_width = 0;
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
if (unary || binary || cop.opcode == OpSConvert || cop.opcode == OpUConvert)
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
bit_width = expression_type(cop.arguments[0]).width;
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
SPIRType::BaseType input_type;
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
bool skip_cast_if_equal_type = opcode_is_sign_invariant(cop.opcode);
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
switch (cop.opcode)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
case OpIEqual:
case OpINotEqual:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
input_type = to_signed_basetype(bit_width);
break;
case OpSLessThan:
case OpSLessThanEqual:
case OpSGreaterThan:
case OpSGreaterThanEqual:
case OpSMod:
case OpSDiv:
case OpShiftRightArithmetic:
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
case OpSConvert:
case OpSNegate:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
input_type = to_signed_basetype(bit_width);
break;
case OpULessThan:
case OpULessThanEqual:
case OpUGreaterThan:
case OpUGreaterThanEqual:
case OpUMod:
case OpUDiv:
case OpShiftRightLogical:
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
case OpUConvert:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
input_type = to_unsigned_basetype(bit_width);
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
break;
default:
input_type = type.basetype;
break;
}
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#undef GLSL_BOP
#undef GLSL_UOP
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
if (binary)
{
if (cop.arguments.size() < 2)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp.");
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
string cast_op0;
string cast_op1;
auto expected_type = binary_op_bitcast_helper(cast_op0, cast_op1, input_type, cop.arguments[0],
cop.arguments[1], skip_cast_if_equal_type);
if (type.basetype != input_type && type.basetype != SPIRType::Boolean)
{
expected_type.basetype = input_type;
auto expr = bitcast_glsl_op(type, expected_type);
expr += '(';
expr += join(cast_op0, " ", op, " ", cast_op1);
expr += ')';
return expr;
}
else
return join("(", cast_op0, " ", op, " ", cast_op1, ")");
}
else if (unary)
{
if (cop.arguments.size() < 1)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp.");
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
// Auto-bitcast to result type as needed.
// Works around various casting scenarios in glslang as there is no OpBitcast for specialization constants.
return join("(", op, bitcast_glsl(type, cop.arguments[0]), ")");
}
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
else if (cop.opcode == OpSConvert || cop.opcode == OpUConvert)
{
if (cop.arguments.size() < 1)
SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp.");
auto &arg_type = expression_type(cop.arguments[0]);
if (arg_type.width < type.width && input_type != arg_type.basetype)
{
auto expected = arg_type;
expected.basetype = input_type;
return join(op, "(", bitcast_glsl(expected, cop.arguments[0]), ")");
}
else
return join(op, "(", to_expression(cop.arguments[0]), ")");
}
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
else
{
if (cop.arguments.size() < 1)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Not enough arguments to OpSpecConstantOp.");
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
return join(op, "(", to_expression(cop.arguments[0]), ")");
}
}
MSL: Consider bool-short remapping for constant expressions as well.
2023-06-07 10:31:36 +00:00
string CompilerGLSL::constant_expression(const SPIRConstant &c,
bool inside_block_like_struct_scope,
bool inside_struct_scope)
Initial commit.
2016-03-02 17:09:16 +00:00
{
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
auto &type = get<SPIRType>(c.constant_type);
Only declare typed initializer list for non-array types. Also, cleanup now redundant constant_expression virtualization for MSL.
2018-09-10 08:04:17 +00:00
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
if (is_pointer(type))
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
{
return backend.null_pointer_literal;
}
else if (!c.subconstants.empty())
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Handles Arrays and structures.
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
string res;
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
MSL: Handle awkward mix and match of Offset / ArrayStride in constants. In normal buffer blocks, every member must be declared, but for constants, you can technically mix and match, causing much pain and suffering ...
2022-03-22 11:10:13 +00:00
// Only consider the decay if we are inside a struct scope where we are emitting a member with Offset decoration.
// Outside a block-like struct declaration, we can always bind to a constant array with templated type.
// Should look at ArrayStride here as well, but it's possible to declare a constant struct
// with Offset = 0, using no ArrayStride on the enclosed array type.
// A particular CTS test hits this scenario.
MSL: Handle constant construct of block-like array types. Need this to be context sensitive, since array of block-like struct is template, but struct of block-like array is C-style. Also, test a mix and match, so we have constant array of block-like struct with array inside. :v
2022-01-17 16:33:57 +00:00
bool array_type_decays = inside_block_like_struct_scope &&
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
is_array(type) &&
Minor cleanup in constant_expression().
2023-06-07 10:30:57 +00:00
!backend.array_is_value_type_in_buffer_blocks;
MSL: Handle constant construct of block-like array types. Need this to be context sensitive, since array of block-like struct is template, but struct of block-like array is C-style. Also, test a mix and match, so we have constant array of block-like struct with array inside. :v
2022-01-17 16:33:57 +00:00
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Allow Metal to use the array<T> template to make arrays a value type
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
bool needs_trailing_tracket = false;
Run format_all.sh.
2018-09-10 08:08:02 +00:00
if (backend.use_initializer_list && backend.use_typed_initializer_list && type.basetype == SPIRType::Struct &&
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
!is_array(type))
Only declare typed initializer list for non-array types. Also, cleanup now redundant constant_expression virtualization for MSL.
2018-09-10 08:04:17 +00:00
{
res = type_to_glsl_constructor(type) + "{ ";
}
Run format_all.sh.
2020-03-19 13:21:42 +00:00
else if (backend.use_initializer_list && backend.use_typed_initializer_list && backend.array_is_value_type &&
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
is_array(type) && !array_type_decays)
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
{
MSL: Consider changed array types for array-of-constant-bool in struct.
2023-06-07 11:54:50 +00:00
const auto *p_type = &type;
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType tmp_type { OpNop };
MSL: Consider changed array types for array-of-constant-bool in struct.
2023-06-07 11:54:50 +00:00
if (inside_struct_scope &&
backend.boolean_in_struct_remapped_type != SPIRType::Boolean &&
type.basetype == SPIRType::Boolean)
{
tmp_type = type;
tmp_type.basetype = backend.boolean_in_struct_remapped_type;
p_type = &tmp_type;
}
res = type_to_glsl_constructor(*p_type) + "({ ";
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
needs_trailing_tracket = true;
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
}
Only declare typed initializer list for non-array types. Also, cleanup now redundant constant_expression virtualization for MSL.
2018-09-10 08:04:17 +00:00
else if (backend.use_initializer_list)
{
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
res = "{ ";
Only declare typed initializer list for non-array types. Also, cleanup now redundant constant_expression virtualization for MSL.
2018-09-10 08:04:17 +00:00
}
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
else
Only declare typed initializer list for non-array types. Also, cleanup now redundant constant_expression virtualization for MSL.
2018-09-10 08:04:17 +00:00
{
res = type_to_glsl_constructor(type) + "(";
}
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
MSL: Handle awkward mix and match of Offset / ArrayStride in constants. In normal buffer blocks, every member must be declared, but for constants, you can technically mix and match, causing much pain and suffering ...
2022-03-22 11:10:13 +00:00
uint32_t subconstant_index = 0;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (auto &elem : c.subconstants)
{
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
if (auto *op = maybe_get<SPIRConstantOp>(elem))
{
res += constant_op_expression(*op);
}
GLSL, MSL: Handle `OpUndef` as part of a constant composite. Fixes the CTS test `dEQP-VK.spirv_assembly.instruction.compute.opundef.undefined_constant_composite` and helps with another, `dEQP-VK.spirv_assembly.instruction.compute.opundef.undefined_spec_constant_composite`. Unfortunately, fixing the latter requires another change.
2022-11-09 00:52:39 +00:00
else if (maybe_get<SPIRUndef>(elem) != nullptr)
{
res += to_name(elem);
}
Emit spec constants directly with Vulkan semantics. Emit an actual spec constant declaration in Vulkan instead of resolving the constant.
2016-10-03 10:52:56 +00:00
else
MSL: Handle awkward mix and match of Offset / ArrayStride in constants. In normal buffer blocks, every member must be declared, but for constants, you can technically mix and match, causing much pain and suffering ...
2022-03-22 11:10:13 +00:00
{
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
auto &subc = get<SPIRConstant>(elem);
if (subc.specialization && !expression_is_forwarded(elem))
res += to_name(elem);
else
MSL: Handle awkward mix and match of Offset / ArrayStride in constants. In normal buffer blocks, every member must be declared, but for constants, you can technically mix and match, causing much pain and suffering ...
2022-03-22 11:10:13 +00:00
{
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
if (!is_array(type) && type.basetype == SPIRType::Struct)
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
{
// When we get down to emitting struct members, override the block-like information.
// For constants, we can freely mix and match block-like state.
inside_block_like_struct_scope =
has_member_decoration(type.self, subconstant_index, DecorationOffset);
}
MSL: Handle awkward mix and match of Offset / ArrayStride in constants. In normal buffer blocks, every member must be declared, but for constants, you can technically mix and match, causing much pain and suffering ...
2022-03-22 11:10:13 +00:00
MSL: Consider bool-short remapping for constant expressions as well.
2023-06-07 10:31:36 +00:00
if (type.basetype == SPIRType::Struct)
inside_struct_scope = true;
res += constant_expression(subc, inside_block_like_struct_scope, inside_struct_scope);
MSL: Implement `CompositeInsert` `OpSpecConstantOp`. This op creates a new composite constant with one element replaced. So, we reconstruct the `SPIRConstant` for the composite constant, but with one of the IDs replaced. Constant initializer lists are memoized for when the result of a `CompositeInsert` is used in another `CompositeInsert`. (I wanted to add a test case for GLSL as well, but for two things: 1. `glslang` in Vulkan mode chokes on the first constant array, insisting that its initializer needs to be a constant. [Bug in glslang?] 2. The declarations for the buffers used by the shader aren't emitted, regardless of whether Vulkan mode is enabled.) Fixes five tests under `dEQP-VK.spirv_assembly.instruction.*.opspecconstantop.vector_related`.
2022-10-26 20:31:10 +00:00
}
MSL: Handle awkward mix and match of Offset / ArrayStride in constants. In normal buffer blocks, every member must be declared, but for constants, you can technically mix and match, causing much pain and suffering ...
2022-03-22 11:10:13 +00:00
}
Emit spec constants directly with Vulkan semantics. Emit an actual spec constant declaration in Vulkan instead of resolving the constant.
2016-10-03 10:52:56 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (&elem != &c.subconstants.back())
res += ", ";
MSL: Handle awkward mix and match of Offset / ArrayStride in constants. In normal buffer blocks, every member must be declared, but for constants, you can technically mix and match, causing much pain and suffering ...
2022-03-22 11:10:13 +00:00
subconstant_index++;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
res += backend.use_initializer_list ? " }" : ")";
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
if (needs_trailing_tracket)
Rework the way arrays are handled in Metal to remove the array copies as they are unnecessary from Metal 1.2. There were cases where copies were not being inserted and others appeared unncessary, using the template type should allow the 'metal' compiler to do the best possible optimisation. The changes are broken into three stages. 1. Allow Metal to use the array<T> template to make arrays a value type. 2. Force the use of C style array declaration for some cases which cannot be wrapped with a template. 3. Threadgroup arrays can't have a wrapper type. 4. Tweak the code to use unsafe_array in a few more places so that we can handle passing arrays of resources into the shader and then through shaders into sub-functions. 5. Handle packed matrix types inside arrays within structs. 6. Make sure that builtin arguments still retain their array qualifiers when used in leaf functions. 7. Fix declaration of array-of-array constants for Metal so we can use the array<T> template.
2019-08-13 22:18:48 +00:00
res += ")";
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return res;
}
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
else if (type.basetype == SPIRType::Struct && type.member_types.size() == 0)
{
// Metal tessellation likes empty structs which are then constant expressions.
Implement constant empty struct correctly on all backends. MSL actually supports empty structs, so enable that path as well.
2019-10-24 15:05:55 +00:00
if (backend.supports_empty_struct)
return "{ }";
else if (backend.use_typed_initializer_list)
Minor cleanup in constant_expression().
2023-06-07 10:30:57 +00:00
return join(type_to_glsl(type), "{ 0 }");
Implement constant empty struct correctly on all backends. MSL actually supports empty structs, so enable that path as well.
2019-10-24 15:05:55 +00:00
else if (backend.use_initializer_list)
return "{ 0 }";
else
Minor cleanup in constant_expression().
2023-06-07 10:30:57 +00:00
return join(type_to_glsl(type), "(0)");
Further updates for pull request #1162; also added two test cases for spvCubemapTo2DArrayFace function and added '--msl-framebuffer-fetch'/ '--msl-emulate-cube-array' compiler options.
2019-09-27 19:49:54 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (c.columns() == 1)
{
MSL: Consider bool-short remapping for constant expressions as well.
2023-06-07 10:31:36 +00:00
auto res = constant_expression_vector(c, 0);
if (inside_struct_scope &&
backend.boolean_in_struct_remapped_type != SPIRType::Boolean &&
type.basetype == SPIRType::Boolean)
{
SPIRType tmp_type = type;
tmp_type.basetype = backend.boolean_in_struct_remapped_type;
res = join(type_to_glsl(tmp_type), "(", res, ")");
}
return res;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
Minor cleanup in constant_expression().
2023-06-07 10:30:57 +00:00
string res = type_to_glsl(type) + "(";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (uint32_t col = 0; col < c.columns(); col++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.specialization_constant_id(col) != 0)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
res += to_name(c.specialization_constant_id(col));
else
res += constant_expression_vector(c, col);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (col + 1 < c.columns())
res += ", ";
}
res += ")";
MSL: Consider bool-short remapping for constant expressions as well.
2023-06-07 10:31:36 +00:00
if (inside_struct_scope &&
backend.boolean_in_struct_remapped_type != SPIRType::Boolean &&
type.basetype == SPIRType::Boolean)
{
SPIRType tmp_type = type;
tmp_type.basetype = backend.boolean_in_struct_remapped_type;
res = join(type_to_glsl(tmp_type), "(", res, ")");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return res;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
address more review comments
2022-06-23 09:40:02 +00:00
#ifdef _MSC_VER
Keep using sprintf on windows.
2022-06-23 09:34:51 +00:00
// snprintf does not exist or is buggy on older MSVC versions, some of them
// being used by MinGW. Use sprintf instead and disable corresponding warning.
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
#pragma warning(push)
#pragma warning(disable : 4996)
#endif
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
string CompilerGLSL::convert_half_to_string(const SPIRConstant &c, uint32_t col, uint32_t row)
{
string res;
float float_value = c.scalar_f16(col, row);
Always value-cast FP16 constants instead of using literals. GL_NV_gpu_shader5 doesn't support "hf", so to avoid lots of complicated workarounds, just value-cast the half literals.
2019-02-20 11:30:01 +00:00
// There is no literal "hf" in GL_NV_gpu_shader5, so to avoid lots
// of complicated workarounds, just value-cast to the half type always.
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
if (std::isnan(float_value) || std::isinf(float_value))
{
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType type { OpTypeFloat };
Always value-cast FP16 constants instead of using literals. GL_NV_gpu_shader5 doesn't support "hf", so to avoid lots of complicated workarounds, just value-cast the half literals.
2019-02-20 11:30:01 +00:00
type.basetype = SPIRType::Half;
type.vecsize = 1;
type.columns = 1;
if (float_value == numeric_limits<float>::infinity())
res = join(type_to_glsl(type), "(1.0 / 0.0)");
else if (float_value == -numeric_limits<float>::infinity())
res = join(type_to_glsl(type), "(-1.0 / 0.0)");
else if (std::isnan(float_value))
res = join(type_to_glsl(type), "(0.0 / 0.0)");
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
else
Always value-cast FP16 constants instead of using literals. GL_NV_gpu_shader5 doesn't support "hf", so to avoid lots of complicated workarounds, just value-cast the half literals.
2019-02-20 11:30:01 +00:00
SPIRV_CROSS_THROW("Cannot represent non-finite floating point constant.");
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
}
else
Add FP16 to HLSL. Cannot be used in buffer types, similar to mediump in GLSL. half is useless, because it's 32-bit in FXC.
2018-03-07 09:21:25 +00:00
{
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType type { OpTypeFloat };
Always value-cast FP16 constants instead of using literals. GL_NV_gpu_shader5 doesn't support "hf", so to avoid lots of complicated workarounds, just value-cast the half literals.
2019-02-20 11:30:01 +00:00
type.basetype = SPIRType::Half;
type.vecsize = 1;
type.columns = 1;
Allow to customize float literals in output
2023-11-22 12:06:05 +00:00
res = join(type_to_glsl(type), "(", format_float(float_value), ")");
Add FP16 to HLSL. Cannot be used in buffer types, similar to mediump in GLSL. half is useless, because it's 32-bit in FXC.
2018-03-07 09:21:25 +00:00
}
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
return res;
}
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
string CompilerGLSL::convert_float_to_string(const SPIRConstant &c, uint32_t col, uint32_t row)
{
string res;
float float_value = c.scalar_f32(col, row);
Fix implicit conversion bug.
2018-02-26 08:15:52 +00:00
if (std::isnan(float_value) || std::isinf(float_value))
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
{
// Use special representation.
if (!is_legacy())
{
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType out_type { OpTypeFloat };
SPIRType in_type { OpTypeInt };
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
out_type.basetype = SPIRType::Float;
in_type.basetype = SPIRType::UInt;
out_type.vecsize = 1;
in_type.vecsize = 1;
out_type.width = 32;
in_type.width = 32;
char print_buffer[32];
Keep using sprintf on windows.
2022-06-23 09:34:51 +00:00
#ifdef _WIN32
sprintf(print_buffer, "0x%xu", c.scalar(col, row));
#else
Fix compilation errors with deprecated sprintf function This commit modifies sprintf calls to fix the following compilation errors using XCode 14.0 beta on MacOS: > 'sprintf' is deprecated: This function is provided for compatibility > reasons only. Due to security concerns inherent in the design of > sprintf(3), it is highly recommended that you use snprintf(3) instead.
2022-06-21 14:28:16 +00:00
snprintf(print_buffer, sizeof(print_buffer), "0x%xu", c.scalar(col, row));
Keep using sprintf on windows.
2022-06-23 09:34:51 +00:00
#endif
Add comment after inf/nan float number for clarifying.
2021-05-26 14:43:26 +00:00
const char *comment = "inf";
if (float_value == -numeric_limits<float>::infinity())
comment = "-inf";
else if (std::isnan(float_value))
comment = "nan";
res = join(bitcast_glsl_op(out_type, in_type), "(", print_buffer, " /* ", comment, " */)");
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
}
else
{
if (float_value == numeric_limits<float>::infinity())
{
if (backend.float_literal_suffix)
res = "(1.0f / 0.0f)";
else
res = "(1.0 / 0.0)";
}
else if (float_value == -numeric_limits<float>::infinity())
{
if (backend.float_literal_suffix)
res = "(-1.0f / 0.0f)";
else
res = "(-1.0 / 0.0)";
}
Fix implicit conversion bug.
2018-02-26 08:15:52 +00:00
else if (std::isnan(float_value))
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
{
if (backend.float_literal_suffix)
res = "(0.0f / 0.0f)";
else
res = "(0.0 / 0.0)";
}
else
SPIRV_CROSS_THROW("Cannot represent non-finite floating point constant.");
}
}
else
{
Allow to customize float literals in output
2023-11-22 12:06:05 +00:00
res = format_float(float_value);
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
if (backend.float_literal_suffix)
res += "f";
}
return res;
}
std::string CompilerGLSL::convert_double_to_string(const SPIRConstant &c, uint32_t col, uint32_t row)
{
string res;
Fix implicit conversion bug.
2018-02-26 08:15:52 +00:00
double double_value = c.scalar_f64(col, row);
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
Fix implicit conversion bug.
2018-02-26 08:15:52 +00:00
if (std::isnan(double_value) || std::isinf(double_value))
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
{
// Use special representation.
if (!is_legacy())
{
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType out_type { OpTypeFloat };
SPIRType in_type { OpTypeInt };
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
out_type.basetype = SPIRType::Double;
in_type.basetype = SPIRType::UInt64;
out_type.vecsize = 1;
in_type.vecsize = 1;
out_type.width = 64;
in_type.width = 64;
uint64_t u64_value = c.scalar_u64(col, row);
GLSL: Add more extension ladder fallbacks for unusual integer sizes.
2022-06-07 13:39:37 +00:00
if (options.es && options.version < 310) // GL_NV_gpu_shader5 fallback requires 310.
SPIRV_CROSS_THROW("64-bit integers not supported in ES profile before version 310.");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_gpu_shader_int64");
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
char print_buffer[64];
Keep using sprintf on windows.
2022-06-23 09:34:51 +00:00
#ifdef _WIN32
sprintf(print_buffer, "0x%llx%s", static_cast<unsigned long long>(u64_value),
backend.long_long_literal_suffix ? "ull" : "ul");
#else
Fix compilation errors with deprecated sprintf function This commit modifies sprintf calls to fix the following compilation errors using XCode 14.0 beta on MacOS: > 'sprintf' is deprecated: This function is provided for compatibility > reasons only. Due to security concerns inherent in the design of > sprintf(3), it is highly recommended that you use snprintf(3) instead.
2022-06-21 14:28:16 +00:00
snprintf(print_buffer, sizeof(print_buffer), "0x%llx%s", static_cast<unsigned long long>(u64_value),
backend.long_long_literal_suffix ? "ull" : "ul");
Keep using sprintf on windows.
2022-06-23 09:34:51 +00:00
#endif
Add comment after inf/nan float number for clarifying.
2021-05-26 14:43:26 +00:00
const char *comment = "inf";
if (double_value == -numeric_limits<double>::infinity())
comment = "-inf";
else if (std::isnan(double_value))
comment = "nan";
res = join(bitcast_glsl_op(out_type, in_type), "(", print_buffer, " /* ", comment, " */)");
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
}
else
{
if (options.es)
SPIRV_CROSS_THROW("FP64 not supported in ES profile.");
if (options.version < 400)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_gpu_shader_fp64");
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
if (double_value == numeric_limits<double>::infinity())
{
if (backend.double_literal_suffix)
res = "(1.0lf / 0.0lf)";
else
res = "(1.0 / 0.0)";
}
else if (double_value == -numeric_limits<double>::infinity())
{
if (backend.double_literal_suffix)
res = "(-1.0lf / 0.0lf)";
else
res = "(-1.0 / 0.0)";
}
Fix implicit conversion bug.
2018-02-26 08:15:52 +00:00
else if (std::isnan(double_value))
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
{
if (backend.double_literal_suffix)
res = "(0.0lf / 0.0lf)";
else
res = "(0.0 / 0.0)";
}
else
SPIRV_CROSS_THROW("Cannot represent non-finite floating point constant.");
}
}
else
{
Allow to customize float literals in output
2023-11-22 12:06:05 +00:00
res = format_double(double_value);
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
if (backend.double_literal_suffix)
res += "lf";
}
return res;
}
address more review comments
2022-06-23 09:40:02 +00:00
#ifdef _MSC_VER
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
#pragma warning(pop)
#endif
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::constant_expression_vector(const SPIRConstant &c, uint32_t vector)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto type = get<SPIRType>(c.constant_type);
type.columns = 1;
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
auto scalar_type = type;
scalar_type.vecsize = 1;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string res;
Do not splat type contructor arguments in HLSL
2016-09-23 16:57:18 +00:00
bool splat = backend.use_constructor_splatting && c.vector_size() > 1;
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
bool swizzle_splat = backend.can_swizzle_scalar && c.vector_size() > 1;
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
if (!type_is_floating_point(type))
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
{
// Cannot swizzle literal integers as a special case.
swizzle_splat = false;
}
if (splat || swizzle_splat)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
{
// Cannot use constant splatting if we have specialization constants somewhere in the vector.
for (uint32_t i = 0; i < c.vector_size(); i++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.specialization_constant_id(vector, i) != 0)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
{
splat = false;
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
swizzle_splat = false;
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
break;
}
}
}
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
if (splat || swizzle_splat)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
if (type.width == 64)
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
{
uint64_t ident = c.scalar_u64(vector, 0);
for (uint32_t i = 1; i < c.vector_size(); i++)
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
{
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
if (ident != c.scalar_u64(vector, i))
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
{
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
splat = false;
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
swizzle_splat = false;
break;
}
}
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
}
else
{
uint32_t ident = c.scalar(vector, 0);
for (uint32_t i = 1; i < c.vector_size(); i++)
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
{
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
if (ident != c.scalar(vector, i))
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
{
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
splat = false;
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
swizzle_splat = false;
}
}
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
if (c.vector_size() > 1 && !swizzle_splat)
res += type_to_glsl(type) + "(";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (type.basetype)
{
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
case SPIRType::Half:
if (splat || swizzle_splat)
{
res += convert_half_to_string(c, vector, 0);
if (swizzle_splat)
res = remap_swizzle(get<SPIRType>(c.constant_type), 1, res);
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
else
res += convert_half_to_string(c, vector, i);
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Float:
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
if (splat || swizzle_splat)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
res += convert_float_to_string(c, vector, 0);
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
if (swizzle_splat)
res = remap_swizzle(get<SPIRType>(c.constant_type), 1, res);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
else
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
res += convert_float_to_string(c, vector, i);
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
case SPIRType::Double:
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
if (splat || swizzle_splat)
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
{
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
res += convert_double_to_string(c, vector, 0);
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
if (swizzle_splat)
res = remap_swizzle(get<SPIRType>(c.constant_type), 1, res);
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
else
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
res += convert_double_to_string(c, vector, i);
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
case SPIRType::Int64:
Improve handling of INT_MIN/INT64_MIN literals. We cannot naively convert these to decimal literals. C/C++ (and thus MSL) has extremely awkward literal promotion rules.
2021-09-30 14:17:04 +00:00
{
auto tmp = type;
tmp.vecsize = 1;
tmp.columns = 1;
auto int64_type = type_to_glsl(tmp);
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
if (splat)
{
Improve handling of INT_MIN/INT64_MIN literals. We cannot naively convert these to decimal literals. C/C++ (and thus MSL) has extremely awkward literal promotion rules.
2021-09-30 14:17:04 +00:00
res += convert_to_string(c.scalar_i64(vector, 0), int64_type, backend.long_long_literal_suffix);
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
else
Improve handling of INT_MIN/INT64_MIN literals. We cannot naively convert these to decimal literals. C/C++ (and thus MSL) has extremely awkward literal promotion rules.
2021-09-30 14:17:04 +00:00
res += convert_to_string(c.scalar_i64(vector, i), int64_type, backend.long_long_literal_suffix);
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
Improve handling of INT_MIN/INT64_MIN literals. We cannot naively convert these to decimal literals. C/C++ (and thus MSL) has extremely awkward literal promotion rules.
2021-09-30 14:17:04 +00:00
}
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
case SPIRType::UInt64:
if (splat)
{
res += convert_to_string(c.scalar_u64(vector, 0));
if (backend.long_long_literal_suffix)
res += "ull";
else
res += "ul";
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
else
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
{
res += convert_to_string(c.scalar_u64(vector, i));
if (backend.long_long_literal_suffix)
res += "ull";
else
res += "ul";
}
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::UInt:
if (splat)
{
res += convert_to_string(c.scalar(vector, 0));
Be a bit smarter about uint on legacy targets. Allow constants (array sizes for example), but using unsigned opcodes, and unsigned-specific opcodes is a problem.
2018-04-17 12:56:49 +00:00
if (is_legacy())
{
// Fake unsigned constant literals with signed ones if possible.
// Things like array sizes, etc, tend to be unsigned even though they could just as easily be signed.
if (c.scalar_i32(vector, 0) < 0)
SPIRV_CROSS_THROW("Tried to convert uint literal into int, but this made the literal negative.");
}
else if (backend.uint32_t_literal_suffix)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res += "u";
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
else
{
res += convert_to_string(c.scalar(vector, i));
Be a bit smarter about uint on legacy targets. Allow constants (array sizes for example), but using unsigned opcodes, and unsigned-specific opcodes is a problem.
2018-04-17 12:56:49 +00:00
if (is_legacy())
{
// Fake unsigned constant literals with signed ones if possible.
// Things like array sizes, etc, tend to be unsigned even though they could just as easily be signed.
if (c.scalar_i32(vector, i) < 0)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Tried to convert uint literal into int, but this made "
"the literal negative.");
Be a bit smarter about uint on legacy targets. Allow constants (array sizes for example), but using unsigned opcodes, and unsigned-specific opcodes is a problem.
2018-04-17 12:56:49 +00:00
}
else if (backend.uint32_t_literal_suffix)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
res += "u";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
case SPIRType::Int:
if (splat)
res += convert_to_string(c.scalar_i32(vector, 0));
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
else
res += convert_to_string(c.scalar_i32(vector, i));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
Support constants of 16-bit integral type in GLSL and MSL. Constants of 8-bit type aren't supported in GLSL, since there's no extension letting you use them.
2018-11-02 19:39:55 +00:00
case SPIRType::UShort:
if (splat)
{
res += convert_to_string(c.scalar(vector, 0));
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Support constants of 16-bit integral type in GLSL and MSL. Constants of 8-bit type aren't supported in GLSL, since there's no extension letting you use them.
2018-11-02 19:39:55 +00:00
else
{
MSL: Fix 16-bit integer literals. There is no suffix, so bitcasts failed.
2019-09-19 08:19:51 +00:00
if (*backend.uint16_t_literal_suffix)
Support constants of 16-bit integral type in GLSL and MSL. Constants of 8-bit type aren't supported in GLSL, since there's no extension letting you use them.
2018-11-02 19:39:55 +00:00
{
MSL: Fix 16-bit integer literals. There is no suffix, so bitcasts failed.
2019-09-19 08:19:51 +00:00
res += convert_to_string(c.scalar_u16(vector, i));
res += backend.uint16_t_literal_suffix;
Support constants of 16-bit integral type in GLSL and MSL. Constants of 8-bit type aren't supported in GLSL, since there's no extension letting you use them.
2018-11-02 19:39:55 +00:00
}
Fix crash when backend.int16_t_literal_suffix set to null. The design of backend.int16_t_literal_suffix and backend.uint16_t_literal_suffix allows them to be set to null, but that was not always tested for. I have removed the expectation that they can be null and set backend.int16_t_literal_suffix to "" when no suffix is needed. That has the same effect, and seemed to be a more usable and defensive approach.
2019-03-28 18:23:32 +00:00
else
MSL: Fix 16-bit integer literals. There is no suffix, so bitcasts failed.
2019-09-19 08:19:51 +00:00
{
// If backend doesn't have a literal suffix, we need to value cast.
res += type_to_glsl(scalar_type);
res += "(";
res += convert_to_string(c.scalar_u16(vector, i));
res += ")";
}
Support constants of 16-bit integral type in GLSL and MSL. Constants of 8-bit type aren't supported in GLSL, since there's no extension letting you use them.
2018-11-02 19:39:55 +00:00
}
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
case SPIRType::Short:
if (splat)
{
res += convert_to_string(c.scalar_i16(vector, 0));
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Support constants of 16-bit integral type in GLSL and MSL. Constants of 8-bit type aren't supported in GLSL, since there's no extension letting you use them.
2018-11-02 19:39:55 +00:00
else
{
MSL: Fix 16-bit integer literals. There is no suffix, so bitcasts failed.
2019-09-19 08:19:51 +00:00
if (*backend.int16_t_literal_suffix)
{
res += convert_to_string(c.scalar_i16(vector, i));
res += backend.int16_t_literal_suffix;
}
else
{
// If backend doesn't have a literal suffix, we need to value cast.
res += type_to_glsl(scalar_type);
res += "(";
res += convert_to_string(c.scalar_i16(vector, i));
res += ")";
}
Support constants of 16-bit integral type in GLSL and MSL. Constants of 8-bit type aren't supported in GLSL, since there's no extension letting you use them.
2018-11-02 19:39:55 +00:00
}
MSL: Fix 16-bit integer literals. There is no suffix, so bitcasts failed.
2019-09-19 08:19:51 +00:00
Support constants of 16-bit integral type in GLSL and MSL. Constants of 8-bit type aren't supported in GLSL, since there's no extension letting you use them.
2018-11-02 19:39:55 +00:00
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
case SPIRType::UByte:
if (splat)
{
res += convert_to_string(c.scalar_u8(vector, 0));
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
else
{
res += type_to_glsl(scalar_type);
res += "(";
res += convert_to_string(c.scalar_u8(vector, i));
res += ")";
}
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
case SPIRType::SByte:
if (splat)
{
res += convert_to_string(c.scalar_i8(vector, 0));
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
else
{
res += type_to_glsl(scalar_type);
res += "(";
res += convert_to_string(c.scalar_i8(vector, i));
res += ")";
}
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
Use Boolean instead of Bool. Xlib.h header uses a very ugly define for Bool which conflicts with SPIRV-Cross. The hassle free solution is to use Boolean instead.
2016-06-05 18:13:45 +00:00
case SPIRType::Boolean:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (splat)
res += c.scalar(vector, 0) ? "true" : "false";
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
Alter the handling of spec consts in non-Vulkan GLSL Previously, when generating non-Vulkan GLSL, each use of a spec constant would be subsituted for its default value and the declaration of the constant itself would be omitted completely. This change slightly alters this behavior. The uses of the constant are kept, as well as the declaration, although the latter is stripped of the layout qualifier. The declaration is also prepended with the following code: #ifndef <constant name>_value #define <constant name> <default constant value> #endif and the constant itself now looks like const <constant type> <constant name> = <constant name>_value; The rationale for this change is that it gives the user a way to provide custom values for specialization constants even when the target does not support them.
2018-10-30 06:31:32 +00:00
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
Add support for LocalSizeId. WorkgroupSize builtin is deprecated in 1.6 and LocalSizeId is supported in Vulkan starting with maintenance4.
2022-01-05 14:53:51 +00:00
res += to_expression(c.specialization_constant_id(vector, i));
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
else
res += c.scalar(vector, i) ? "true" : "false";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
default:
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Invalid constant expression basetype.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
if (c.vector_size() > 1 && !swizzle_splat)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res += ")";
return res;
Initial commit.
2016-03-02 17:09:16 +00:00
}
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
SPIRExpression &CompilerGLSL::emit_uninitialized_temporary_expression(uint32_t type, uint32_t id)
{
forced_temporaries.insert(id);
emit_uninitialized_temporary(type, id);
return set<SPIRExpression>(id, to_name(id), type, true);
}
void CompilerGLSL::emit_uninitialized_temporary(uint32_t result_type, uint32_t result_id)
{
// If we're declaring temporaries inside continue blocks,
// we must declare the temporary in the loop header so that the continue block can avoid declaring new variables.
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
if (!block_temporary_hoisting && current_continue_block && !hoisted_temporaries.count(result_id))
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
{
auto &header = get<SPIRBlock>(current_continue_block->loop_dominator);
if (find_if(begin(header.declare_temporary), end(header.declare_temporary),
[result_type, result_id](const pair<uint32_t, uint32_t> &tmp) {
return tmp.first == result_type && tmp.second == result_id;
}) == end(header.declare_temporary))
{
header.declare_temporary.emplace_back(result_type, result_id);
hoisted_temporaries.insert(result_id);
force_recompile();
}
}
else if (hoisted_temporaries.count(result_id) == 0)
{
auto &type = get<SPIRType>(result_type);
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
auto &flags = get_decoration_bitset(result_id);
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
// The result_id has not been made into an expression yet, so use flags interface.
add_local_variable_name(result_id);
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
string initializer;
if (options.force_zero_initialized_variables && type_can_zero_initialize(type))
initializer = join(" = ", to_zero_initialized_expression(result_type));
statement(flags_to_qualifiers_glsl(type, flags), variable_decl(type, to_name(result_id)), initializer, ";");
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::declare_temporary(uint32_t result_type, uint32_t result_id)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &type = get<SPIRType>(result_type);
// If we're declaring temporaries inside continue blocks,
// we must declare the temporary in the loop header so that the continue block can avoid declaring new variables.
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
if (!block_temporary_hoisting && current_continue_block && !hoisted_temporaries.count(result_id))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
auto &header = get<SPIRBlock>(current_continue_block->loop_dominator);
if (find_if(begin(header.declare_temporary), end(header.declare_temporary),
Non-functional: Update formatting.
2016-05-23 11:30:02 +00:00
[result_type, result_id](const pair<uint32_t, uint32_t> &tmp) {
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return tmp.first == result_type && tmp.second == result_id;
Run format_all.sh.
2017-11-17 12:38:29 +00:00
}) == end(header.declare_temporary))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
header.declare_temporary.emplace_back(result_type, result_id);
Fix CFG for forwarded temporaries. Forwarded temporaries would never declare a temporary. Figure out all result types ahead of time so we can deal with those temporaries as well.
2018-01-18 11:07:10 +00:00
hoisted_temporaries.insert(result_id);
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
force_recompile_guarantee_forward_progress();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
return join(to_name(result_id), " = ");
}
Fix complicated Phi case. A continue block might have used a temporary which existed only in the loop body.
2017-11-21 08:27:49 +00:00
else if (hoisted_temporaries.count(result_id))
{
// The temporary has already been declared earlier, so just "declare" the temporary by writing to it.
return join(to_name(result_id), " = ");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
{
// The result_id has not been made into an expression yet, so use flags interface.
Fix name aliasing for temporary variables.
2018-03-24 00:53:08 +00:00
add_local_variable_name(result_id);
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
auto &flags = get_decoration_bitset(result_id);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
return join(flags_to_qualifiers_glsl(type, flags), variable_decl(type, to_name(result_id)), " = ");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
bool CompilerGLSL::expression_is_forwarded(uint32_t id) const
Initial commit.
2016-03-02 17:09:16 +00:00
{
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
return forwarded_temporaries.count(id) != 0;
}
bool CompilerGLSL::expression_suppresses_usage_tracking(uint32_t id) const
{
return suppressed_usage_tracking.count(id) != 0;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Implement context-sensitive expression read tracking. When inside a loop, treat any read of outer expressions to happen multiple times, forcing a temporary of said outer expressions. This avoids the problem where we can end up relying on loop-invariant code motion to happen in the compiler when converting optimized shaders.
2020-06-29 10:20:35 +00:00
bool CompilerGLSL::expression_read_implies_multiple_reads(uint32_t id) const
{
auto *expr = maybe_get<SPIRExpression>(id);
if (!expr)
return false;
// If we're emitting code at a deeper loop level than when we emitted the expression,
// we're probably reading the same expression over and over.
return current_loop_level > expr->emitted_loop_level;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
SPIRExpression &CompilerGLSL::emit_op(uint32_t result_type, uint32_t result_id, const string &rhs, bool forwarding,
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
bool suppress_usage_tracking)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (forwarding && (forced_temporaries.find(result_id) == end(forced_temporaries)))
{
// Just forward it without temporary.
// If the forward is trivial, we do not force flushing to temporary for this expression.
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
forwarded_temporaries.insert(result_id);
if (suppress_usage_tracking)
suppressed_usage_tracking.insert(result_id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
return set<SPIRExpression>(result_id, rhs, result_type, true);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
// If expression isn't immutable, bind it to a temporary and make the new temporary immutable (they always are).
statement(declare_temporary(result_type, result_id), rhs, ";");
return set<SPIRExpression>(result_id, to_name(result_id), result_type, true);
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::emit_unary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op)
{
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
bool forward = should_forward(op0);
Also unpack regular unary/binary operations on MSL. Apparently MSL gets confused when you have packed_float3 op float3 ...
2018-06-11 14:21:38 +00:00
emit_op(result_type, result_id, join(op, to_enclosed_unpacked_expression(op0)), forward);
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
inherit_expression_dependencies(result_id, op0);
Initial commit.
2016-03-02 17:09:16 +00:00
}
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
void CompilerGLSL::emit_unary_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op)
{
auto &type = get<SPIRType>(result_type);
bool forward = should_forward(op0);
emit_op(result_type, result_id, join(type_to_glsl(type), "(", op, to_enclosed_unpacked_expression(op0), ")"), forward);
inherit_expression_dependencies(result_id, op0);
}
virtual emit_mesh_tasks
2023-03-21 20:08:59 +00:00
void CompilerGLSL::emit_mesh_tasks(SPIRBlock &block)
{
statement("EmitMeshTasksEXT(",
to_unpacked_expression(block.mesh.groups[0]), ", ",
to_unpacked_expression(block.mesh.groups[1]), ", ",
to_unpacked_expression(block.mesh.groups[2]), ");");
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::emit_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op)
{
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
// Various FP arithmetic opcodes such as add, sub, mul will hit this.
bool force_temporary_precise = backend.support_precise_qualifier &&
has_decoration(result_id, DecorationNoContraction) &&
type_is_floating_point(get<SPIRType>(result_type));
bool forward = should_forward(op0) && should_forward(op1) && !force_temporary_precise;
Also unpack regular unary/binary operations on MSL. Apparently MSL gets confused when you have packed_float3 op float3 ...
2018-06-11 14:21:38 +00:00
emit_op(result_type, result_id,
join(to_enclosed_unpacked_expression(op0), " ", op, " ", to_enclosed_unpacked_expression(op1)), forward);
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
}
Fix OpLogicalNot in HLSL
2017-03-24 14:00:48 +00:00
void CompilerGLSL::emit_unrolled_unary_op(uint32_t result_type, uint32_t result_id, uint32_t operand, const char *op)
{
auto &type = get<SPIRType>(result_type);
auto expr = type_to_glsl_constructor(type);
expr += '(';
for (uint32_t i = 0; i < type.vecsize; i++)
{
// Make sure to call to_expression multiple times to ensure
// that these expressions are properly flushed to temporaries if needed.
expr += op;
Deal with packed expressions in more scenarios. Make a new "to_extract_component_expression" helper.
2018-05-25 08:56:27 +00:00
expr += to_extract_component_expression(operand, i);
Fix OpLogicalNot in HLSL
2017-03-24 14:00:48 +00:00
if (i + 1 < type.vecsize)
expr += ", ";
}
expr += ')';
emit_op(result_type, result_id, expr, should_forward(operand));
inherit_expression_dependencies(result_id, operand);
}
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
void CompilerGLSL::emit_unrolled_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
HLSL: Fix unrolled S/G LE/LT/GE/GT opcodes. Need to bitcast the unrolled expressions as well.
2019-10-14 14:08:39 +00:00
const char *op, bool negate, SPIRType::BaseType expected_type)
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
{
HLSL: Fix unrolled S/G LE/LT/GE/GT opcodes. Need to bitcast the unrolled expressions as well.
2019-10-14 14:08:39 +00:00
auto &type0 = expression_type(op0);
auto &type1 = expression_type(op1);
SPIRType target_type0 = type0;
SPIRType target_type1 = type1;
target_type0.basetype = expected_type;
target_type1.basetype = expected_type;
target_type0.vecsize = 1;
target_type1.vecsize = 1;
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
auto &type = get<SPIRType>(result_type);
auto expr = type_to_glsl_constructor(type);
expr += '(';
for (uint32_t i = 0; i < type.vecsize; i++)
{
// Make sure to call to_expression multiple times to ensure
// that these expressions are properly flushed to temporaries if needed.
HLSL: Partially implement Unordered compare. We cannot correctly implement unordered equal/ordered not equal without a lot of extra instructions which slows normal code down.
2019-10-14 13:04:00 +00:00
if (negate)
expr += "!(";
HLSL: Fix unrolled S/G LE/LT/GE/GT opcodes. Need to bitcast the unrolled expressions as well.
2019-10-14 14:08:39 +00:00
if (expected_type != SPIRType::Unknown && type0.basetype != expected_type)
expr += bitcast_expression(target_type0, type0.basetype, to_extract_component_expression(op0, i));
else
expr += to_extract_component_expression(op0, i);
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
expr += ' ';
expr += op;
expr += ' ';
HLSL: Fix unrolled S/G LE/LT/GE/GT opcodes. Need to bitcast the unrolled expressions as well.
2019-10-14 14:08:39 +00:00
if (expected_type != SPIRType::Unknown && type1.basetype != expected_type)
expr += bitcast_expression(target_type1, type1.basetype, to_extract_component_expression(op1, i));
else
expr += to_extract_component_expression(op1, i);
HLSL: Partially implement Unordered compare. We cannot correctly implement unordered equal/ordered not equal without a lot of extra instructions which slows normal code down.
2019-10-14 13:04:00 +00:00
if (negate)
expr += ")";
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
if (i + 1 < type.vecsize)
expr += ", ";
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
}
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
expr += ')';
emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1));
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
SPIRType CompilerGLSL::binary_op_bitcast_helper(string &cast_op0, string &cast_op1, SPIRType::BaseType &input_type,
uint32_t op0, uint32_t op1, bool skip_cast_if_equal_type)
{
auto &type0 = expression_type(op0);
auto &type1 = expression_type(op1);
// We have to bitcast if our inputs are of different type, or if our types are not equal to expected inputs.
// For some functions like OpIEqual and INotEqual, we don't care if inputs are of different types than expected
// since equality test is exactly the same.
bool cast = (type0.basetype != type1.basetype) || (!skip_cast_if_equal_type && type0.basetype != input_type);
// Create a fake type so we can bitcast to it.
// We only deal with regular arithmetic types here like int, uints and so on.
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType expected_type{type0.op};
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
expected_type.basetype = input_type;
expected_type.vecsize = type0.vecsize;
expected_type.columns = type0.columns;
expected_type.width = type0.width;
if (cast)
{
cast_op0 = bitcast_glsl(expected_type, op0);
cast_op1 = bitcast_glsl(expected_type, op1);
}
else
{
// If we don't cast, our actual input type is that of the first (or second) argument.
Also unpack regular unary/binary operations on MSL. Apparently MSL gets confused when you have packed_float3 op float3 ...
2018-06-11 14:21:38 +00:00
cast_op0 = to_enclosed_unpacked_expression(op0);
cast_op1 = to_enclosed_unpacked_expression(op1);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
input_type = type0.basetype;
}
return expected_type;
}
GLSL: Support f16x2 <-> f32 bitcast. There is no native formulation, so introduce a concept of a "complex" bitcast to handle odd-ball cases which have no native unary operation.
2020-04-21 21:27:33 +00:00
bool CompilerGLSL::emit_complex_bitcast(uint32_t result_type, uint32_t id, uint32_t op0)
{
// Some bitcasts may require complex casting sequences, and are implemented here.
// Otherwise a simply unary function will do with bitcast_glsl_op.
auto &output_type = get<SPIRType>(result_type);
auto &input_type = expression_type(op0);
string expr;
if (output_type.basetype == SPIRType::Half && input_type.basetype == SPIRType::Float && input_type.vecsize == 1)
expr = join("unpackFloat2x16(floatBitsToUint(", to_unpacked_expression(op0), "))");
Run format_all.sh.
2020-07-01 09:42:58 +00:00
else if (output_type.basetype == SPIRType::Float && input_type.basetype == SPIRType::Half &&
input_type.vecsize == 2)
GLSL: Support f16x2 <-> f32 bitcast. There is no native formulation, so introduce a concept of a "complex" bitcast to handle odd-ball cases which have no native unary operation.
2020-04-21 21:27:33 +00:00
expr = join("uintBitsToFloat(packFloat2x16(", to_unpacked_expression(op0), "))");
else
return false;
emit_op(result_type, id, expr, should_forward(op0));
return true;
}
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
void CompilerGLSL::emit_binary_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
const char *op, SPIRType::BaseType input_type,
bool skip_cast_if_equal_type,
bool implicit_integer_promotion)
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
string cast_op0, cast_op1;
auto expected_type = binary_op_bitcast_helper(cast_op0, cast_op1, input_type, op0, op1, skip_cast_if_equal_type);
auto &out_type = get<SPIRType>(result_type);
// We might have casted away from the result type, so bitcast again.
// For example, arithmetic right shift with uint inputs.
// Special case boolean outputs since relational opcodes output booleans instead of int/uint.
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
auto bitop = join(cast_op0, " ", op, " ", cast_op1);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
string expr;
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
if (implicit_integer_promotion)
{
// Simple value cast.
expr = join(type_to_glsl(out_type), '(', bitop, ')');
}
else if (out_type.basetype != input_type && out_type.basetype != SPIRType::Boolean)
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
expected_type.basetype = input_type;
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
expr = join(bitcast_glsl_op(out_type, expected_type), '(', bitop, ')');
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
}
else
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
{
expr = std::move(bitop);
}
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1));
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::emit_unary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op)
{
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
bool forward = should_forward(op0);
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
emit_op(result_type, result_id, join(op, "(", to_unpacked_expression(op0), ")"), forward);
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
inherit_expression_dependencies(result_id, op0);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
void CompilerGLSL::emit_binary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
const char *op)
Initial commit.
2016-03-02 17:09:16 +00:00
{
GLSL: Don't create temporaries for sampled image types in GLSL. This fixes a bug that was exposed when targeting GLSL with Vulkan semantics while 'force_temporary' is enabled.
2023-02-23 21:27:22 +00:00
// Opaque types (e.g. OpTypeSampledImage) must always be forwarded in GLSL
const auto &type = get_type(result_type);
bool must_forward = type_is_opaque_value(type);
bool forward = must_forward || (should_forward(op0) && should_forward(op1));
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
emit_op(result_type, result_id, join(op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), ")"),
forward);
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
void CompilerGLSL::emit_atomic_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
const char *op)
{
GLSL: Add basic support for GL_EXT_shader_atomic_float.
2022-05-27 10:12:50 +00:00
auto &type = get<SPIRType>(result_type);
if (type_is_floating_point(type))
{
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Floating point atomics requires Vulkan semantics.");
if (options.es)
SPIRV_CROSS_THROW("Floating point atomics requires desktop GLSL.");
require_extension_internal("GL_EXT_shader_atomic_float");
}
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
forced_temporaries.insert(result_id);
emit_op(result_type, result_id,
join(op, "(", to_non_uniform_aware_expression(op0), ", ",
to_unpacked_expression(op1), ")"), false);
flush_all_atomic_capable_variables();
}
void CompilerGLSL::emit_atomic_func_op(uint32_t result_type, uint32_t result_id,
uint32_t op0, uint32_t op1, uint32_t op2,
const char *op)
{
forced_temporaries.insert(result_id);
emit_op(result_type, result_id,
join(op, "(", to_non_uniform_aware_expression(op0), ", ",
to_unpacked_expression(op1), ", ", to_unpacked_expression(op2), ")"), false);
flush_all_atomic_capable_variables();
}
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
void CompilerGLSL::emit_unary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op,
SPIRType::BaseType input_type, SPIRType::BaseType expected_result_type)
{
auto &out_type = get<SPIRType>(result_type);
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
auto &expr_type = expression_type(op0);
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
auto expected_type = out_type;
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
// Bit-widths might be different in unary cases because we use it for SConvert/UConvert and friends.
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
expected_type.basetype = input_type;
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
expected_type.width = expr_type.width;
HLSL: Support logical subgroup ops.
2021-03-08 11:52:03 +00:00
string cast_op;
if (expr_type.basetype != input_type)
{
if (expr_type.basetype == SPIRType::Boolean)
cast_op = join(type_to_glsl(expected_type), "(", to_unpacked_expression(op0), ")");
else
cast_op = bitcast_glsl(expected_type, op0);
}
else
cast_op = to_unpacked_expression(op0);
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
string expr;
if (out_type.basetype != expected_result_type)
{
expected_type.basetype = expected_result_type;
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
expected_type.width = out_type.width;
HLSL: Support logical subgroup ops.
2021-03-08 11:52:03 +00:00
if (out_type.basetype == SPIRType::Boolean)
expr = type_to_glsl(out_type);
else
expr = bitcast_glsl_op(out_type, expected_type);
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
expr += '(';
expr += join(op, "(", cast_op, ")");
expr += ')';
}
else
{
expr += join(op, "(", cast_op, ")");
}
emit_op(result_type, result_id, expr, should_forward(op0));
inherit_expression_dependencies(result_id, op0);
}
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
// Very special case. Handling bitfieldExtract requires us to deal with different bitcasts of different signs
// and different vector sizes all at once. Need a special purpose method here.
void CompilerGLSL::emit_trinary_func_op_bitextract(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
uint32_t op2, const char *op,
SPIRType::BaseType expected_result_type,
Run format_all.sh.
2019-08-28 12:25:26 +00:00
SPIRType::BaseType input_type0, SPIRType::BaseType input_type1,
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
SPIRType::BaseType input_type2)
{
auto &out_type = get<SPIRType>(result_type);
auto expected_type = out_type;
expected_type.basetype = input_type0;
string cast_op0 =
Run format_all.sh.
2019-08-28 12:25:26 +00:00
expression_type(op0).basetype != input_type0 ? bitcast_glsl(expected_type, op0) : to_unpacked_expression(op0);
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
auto op1_expr = to_unpacked_expression(op1);
auto op2_expr = to_unpacked_expression(op2);
// Use value casts here instead. Input must be exactly int or uint, but SPIR-V might be 16-bit.
expected_type.basetype = input_type1;
expected_type.vecsize = 1;
Run format_all.sh.
2019-08-28 12:25:26 +00:00
string cast_op1 = expression_type(op1).basetype != input_type1 ?
join(type_to_glsl_constructor(expected_type), "(", op1_expr, ")") :
op1_expr;
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
expected_type.basetype = input_type2;
expected_type.vecsize = 1;
Run format_all.sh.
2019-08-28 12:25:26 +00:00
string cast_op2 = expression_type(op2).basetype != input_type2 ?
join(type_to_glsl_constructor(expected_type), "(", op2_expr, ")") :
op2_expr;
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
string expr;
if (out_type.basetype != expected_result_type)
{
expected_type.vecsize = out_type.vecsize;
expected_type.basetype = expected_result_type;
expr = bitcast_glsl_op(out_type, expected_type);
expr += '(';
expr += join(op, "(", cast_op0, ", ", cast_op1, ", ", cast_op2, ")");
expr += ')';
}
else
{
expr += join(op, "(", cast_op0, ", ", cast_op1, ", ", cast_op2, ")");
}
emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1) && should_forward(op2));
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
inherit_expression_dependencies(result_id, op2);
}
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
void CompilerGLSL::emit_trinary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
uint32_t op2, const char *op, SPIRType::BaseType input_type)
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
{
auto &out_type = get<SPIRType>(result_type);
auto expected_type = out_type;
expected_type.basetype = input_type;
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
string cast_op0 =
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
expression_type(op0).basetype != input_type ? bitcast_glsl(expected_type, op0) : to_unpacked_expression(op0);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
string cast_op1 =
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
expression_type(op1).basetype != input_type ? bitcast_glsl(expected_type, op1) : to_unpacked_expression(op1);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
string cast_op2 =
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
expression_type(op2).basetype != input_type ? bitcast_glsl(expected_type, op2) : to_unpacked_expression(op2);
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
string expr;
if (out_type.basetype != input_type)
{
expr = bitcast_glsl_op(out_type, expected_type);
expr += '(';
expr += join(op, "(", cast_op0, ", ", cast_op1, ", ", cast_op2, ")");
expr += ')';
}
else
{
expr += join(op, "(", cast_op0, ", ", cast_op1, ", ", cast_op2, ")");
}
emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1) && should_forward(op2));
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
inherit_expression_dependencies(result_id, op2);
}
GLSL: Deal with sign in subgroup Min/Max operations.
2020-01-09 11:01:54 +00:00
void CompilerGLSL::emit_binary_func_op_cast_clustered(uint32_t result_type, uint32_t result_id, uint32_t op0,
uint32_t op1, const char *op, SPIRType::BaseType input_type)
{
// Special purpose method for implementing clustered subgroup opcodes.
// Main difference is that op1 does not participate in any casting, it needs to be a literal.
auto &out_type = get<SPIRType>(result_type);
auto expected_type = out_type;
expected_type.basetype = input_type;
string cast_op0 =
expression_type(op0).basetype != input_type ? bitcast_glsl(expected_type, op0) : to_unpacked_expression(op0);
string expr;
if (out_type.basetype != input_type)
{
expr = bitcast_glsl_op(out_type, expected_type);
expr += '(';
expr += join(op, "(", cast_op0, ", ", to_expression(op1), ")");
expr += ')';
}
else
{
expr += join(op, "(", cast_op0, ", ", to_expression(op1), ")");
}
emit_op(result_type, result_id, expr, should_forward(op0));
inherit_expression_dependencies(result_id, op0);
}
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
void CompilerGLSL::emit_binary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
const char *op, SPIRType::BaseType input_type, bool skip_cast_if_equal_type)
{
string cast_op0, cast_op1;
auto expected_type = binary_op_bitcast_helper(cast_op0, cast_op1, input_type, op0, op1, skip_cast_if_equal_type);
auto &out_type = get<SPIRType>(result_type);
// Special case boolean outputs since relational opcodes output booleans instead of int/uint.
string expr;
Use Boolean instead of Bool. Xlib.h header uses a very ugly define for Bool which conflicts with SPIRV-Cross. The hassle free solution is to use Boolean instead.
2016-06-05 18:13:45 +00:00
if (out_type.basetype != input_type && out_type.basetype != SPIRType::Boolean)
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
expected_type.basetype = input_type;
expr = bitcast_glsl_op(out_type, expected_type);
expr += '(';
expr += join(op, "(", cast_op0, ", ", cast_op1, ")");
expr += ')';
}
else
{
expr += join(op, "(", cast_op0, ", ", cast_op1, ")");
}
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
emit_op(result_type, result_id, expr, should_forward(op0) && should_forward(op1));
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
void CompilerGLSL::emit_trinary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
uint32_t op2, const char *op)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
bool forward = should_forward(op0) && should_forward(op1) && should_forward(op2);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_op(result_type, result_id,
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
join(op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), ", ",
to_unpacked_expression(op2), ")"),
forward);
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
inherit_expression_dependencies(result_id, op2);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
void CompilerGLSL::emit_quaternary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
uint32_t op2, uint32_t op3, const char *op)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
bool forward = should_forward(op0) && should_forward(op1) && should_forward(op2) && should_forward(op3);
Run format_all.sh.
2017-11-17 12:38:29 +00:00
emit_op(result_type, result_id,
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
join(op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), ", ",
to_unpacked_expression(op2), ", ", to_unpacked_expression(op3), ")"),
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
forward);
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
inherit_expression_dependencies(result_id, op2);
inherit_expression_dependencies(result_id, op3);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
void CompilerGLSL::emit_bitfield_insert_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1,
uint32_t op2, uint32_t op3, const char *op,
SPIRType::BaseType offset_count_type)
{
// Only need to cast offset/count arguments. Types of base/insert must be same as result type,
// and bitfieldInsert is sign invariant.
Run format_all.sh.
2019-08-28 12:25:26 +00:00
bool forward = should_forward(op0) && should_forward(op1) && should_forward(op2) && should_forward(op3);
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
auto op0_expr = to_unpacked_expression(op0);
auto op1_expr = to_unpacked_expression(op1);
auto op2_expr = to_unpacked_expression(op2);
auto op3_expr = to_unpacked_expression(op3);
Added an Op field to SPIRType This field allows telling what the 'head' of the type is, without having to look at parent types.
2023-11-30 11:28:50 +00:00
assert(offset_count_type == SPIRType::UInt || offset_count_type == SPIRType::Int);
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType target_type { OpTypeInt };
Added an Op field to SPIRType This field allows telling what the 'head' of the type is, without having to look at parent types.
2023-11-30 11:28:50 +00:00
target_type.width = 32;
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
target_type.vecsize = 1;
target_type.basetype = offset_count_type;
if (expression_type(op2).basetype != offset_count_type)
{
// Value-cast here. Input might be 16-bit. GLSL requires int.
op2_expr = join(type_to_glsl_constructor(target_type), "(", op2_expr, ")");
}
if (expression_type(op3).basetype != offset_count_type)
{
// Value-cast here. Input might be 16-bit. GLSL requires int.
op3_expr = join(type_to_glsl_constructor(target_type), "(", op3_expr, ")");
}
Run format_all.sh.
2019-08-28 12:25:26 +00:00
emit_op(result_type, result_id, join(op, "(", op0_expr, ", ", op1_expr, ", ", op2_expr, ", ", op3_expr, ")"),
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
forward);
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
inherit_expression_dependencies(result_id, op2);
inherit_expression_dependencies(result_id, op3);
}
GLSL: Remove unused `lod` argument from legacy_tex_op()
2020-11-07 11:43:53 +00:00
string CompilerGLSL::legacy_tex_op(const std::string &op, const SPIRType &imgtype, uint32_t tex)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
const char *type;
switch (imgtype.image.dim)
{
case spv::Dim1D:
GLSL: Implement 1D texture emulation for ES. ES does not support 1D images at all. Fake it by promoting 1D images to 2D.
2022-05-27 09:51:34 +00:00
// Force 2D path for ES.
if (options.es)
type = (imgtype.image.arrayed && !options.es) ? "2DArray" : "2D";
else
type = (imgtype.image.arrayed && !options.es) ? "1DArray" : "1D";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case spv::Dim2D:
For arrayed textures in GLSL < 130, require GL_EXT_texture_array and emit correct texture lookup function names
2016-09-17 08:01:50 +00:00
type = (imgtype.image.arrayed && !options.es) ? "2DArray" : "2D";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case spv::Dim3D:
type = "3D";
break;
case spv::DimCube:
type = "Cube";
break;
Added support for sampler2DRect and legacy texture2DRect() sampling function
2019-01-06 20:21:59 +00:00
case spv::DimRect:
type = "2DRect";
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case spv::DimBuffer:
type = "Buffer";
break;
case spv::DimSubpassData:
type = "2D";
break;
default:
type = "";
break;
}
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
// In legacy GLSL, an extension is required for textureLod in the fragment
// shader or textureGrad anywhere.
bool legacy_lod_ext = false;
auto &execution = get_entry_point();
if (op == "textureGrad" || op == "textureProjGrad" ||
((op == "textureLod" || op == "textureProjLod") && execution.model != ExecutionModelVertex))
Legacy GL_ARB_shader_texture_lod support.
2016-11-21 21:37:20 +00:00
{
Put check for lod legality in its own function Also add requested code style changes.
2017-03-23 12:25:24 +00:00
if (is_legacy_es())
{
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
legacy_lod_ext = true;
require_extension_internal("GL_EXT_shader_texture_lod");
Put check for lod legality in its own function Also add requested code style changes.
2017-03-23 12:25:24 +00:00
}
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
else if (is_legacy_desktop())
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_shader_texture_lod");
Legacy GL_ARB_shader_texture_lod support.
2016-11-21 21:37:20 +00:00
}
Clean up.
2016-09-17 13:56:23 +00:00
Fixed emission of some legacy texture ops without requiring the appropriate extensions
2018-06-25 09:11:46 +00:00
if (op == "textureLodOffset" || op == "textureProjLodOffset")
{
if (is_legacy_es())
SPIRV_CROSS_THROW(join(op, " not allowed in legacy ES"));
require_extension_internal("GL_EXT_gpu_shader4");
}
Run format_all.sh.
2018-06-28 21:00:26 +00:00
// GLES has very limited support for shadow samplers.
Fixed emission of some legacy texture ops without requiring the appropriate extensions
2018-06-25 09:11:46 +00:00
// Basically shadow2D and shadow2DProj work through EXT_shadow_samplers,
// everything else can just throw
Separate (partially) the tracking of depth images from depth compare ops. SPIR-V allows an image to be marked as a depth image, but with a non-depth format. Such images should be read or sampled as vectors instead of scalars, except when they are subject to compare operations. Don't mark an OpSampledImage as using a compare operation just because the image contains a depth marker. Instead, require that a compare operation is actually used on that image. Compiler::image_is_comparison() was really testing whether an image is a depth image, since it incorporates the depth marker. Rename that function to is_depth_image(), to clarify what it is really testing. In Compiler::is_depth_image(), do not treat an image as a depth image if it has been explicitly marked with a color format, unless the image is subject to compare operations. In CompilerMSL::to_function_name(), test for compare operations specifically, rather than assuming them from the depth-image marker. CompilerGLSL and CompilerMSL still contain a number of internal tests that use is_depth_image() both for testing for a depth image, and for testing whether compare operations are being used. I've left these as they are for now, but these should be cleaned up at some point. Add unit tests for fetch/sample depth images with color formats and no compare ops.
2021-11-08 20:59:45 +00:00
bool is_comparison = is_depth_image(imgtype, tex);
GLSL: Legacy / extension fallbacks for textureSize and texelFetch
2020-11-09 14:26:46 +00:00
if (is_comparison && is_legacy_es())
Fixed emission of some legacy texture ops without requiring the appropriate extensions
2018-06-25 09:11:46 +00:00
{
if (op == "texture" || op == "textureProj")
require_extension_internal("GL_EXT_shadow_samplers");
else
SPIRV_CROSS_THROW(join(op, " not allowed on depth samplers in legacy ES"));
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
if (imgtype.image.dim == spv::DimCube)
return "shadowCubeNV";
Fixed emission of some legacy texture ops without requiring the appropriate extensions
2018-06-25 09:11:46 +00:00
}
GLSL: Legacy / extension fallbacks for textureSize and texelFetch
2020-11-09 14:26:46 +00:00
if (op == "textureSize")
{
if (is_legacy_es())
SPIRV_CROSS_THROW("textureSize not supported in legacy ES");
if (is_comparison)
SPIRV_CROSS_THROW("textureSize not supported on shadow sampler in legacy GLSL");
require_extension_internal("GL_EXT_gpu_shader4");
}
if (op == "texelFetch" && is_legacy_es())
SPIRV_CROSS_THROW("texelFetch not supported in legacy ES");
bool is_es_and_depth = is_legacy_es() && is_comparison;
std::string type_prefix = is_comparison ? "shadow" : "texture";
Moved check for depth texture and shadowXY emission completely to legacy_tex_op()
2018-06-22 08:40:01 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (op == "texture")
Fixed emission of some legacy texture ops without requiring the appropriate extensions
2018-06-25 09:11:46 +00:00
return is_es_and_depth ? join(type_prefix, type, "EXT") : join(type_prefix, type);
Put check for lod legality in its own function Also add requested code style changes.
2017-03-23 12:25:24 +00:00
else if (op == "textureLod")
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
return join(type_prefix, type, legacy_lod_ext ? "LodEXT" : "Lod");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (op == "textureProj")
Fixed emission of some legacy texture ops without requiring the appropriate extensions
2018-06-25 09:11:46 +00:00
return join(type_prefix, type, is_es_and_depth ? "ProjEXT" : "Proj");
Added generation of the textureXYZGrad() legacy GLSL instruction
2018-03-11 14:59:06 +00:00
else if (op == "textureGrad")
Moved check for depth texture and shadowXY emission completely to legacy_tex_op()
2018-06-22 08:40:01 +00:00
return join(type_prefix, type, is_legacy_es() ? "GradEXT" : is_legacy_desktop() ? "GradARB" : "Grad");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (op == "textureProjLod")
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
return join(type_prefix, type, legacy_lod_ext ? "ProjLodEXT" : "ProjLod");
Moved check for depth texture and shadowXY emission completely to legacy_tex_op()
2018-06-22 08:40:01 +00:00
else if (op == "textureLodOffset")
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
return join(type_prefix, type, "LodOffset");
Moved check for depth texture and shadowXY emission completely to legacy_tex_op()
2018-06-22 08:40:01 +00:00
else if (op == "textureProjGrad")
Run format_all.sh.
2018-06-28 21:00:26 +00:00
return join(type_prefix, type,
is_legacy_es() ? "ProjGradEXT" : is_legacy_desktop() ? "ProjGradARB" : "ProjGrad");
Moved check for depth texture and shadowXY emission completely to legacy_tex_op()
2018-06-22 08:40:01 +00:00
else if (op == "textureProjLodOffset")
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
return join(type_prefix, type, "ProjLodOffset");
GLSL: Legacy / extension fallbacks for textureSize and texelFetch
2020-11-09 14:26:46 +00:00
else if (op == "textureSize")
return join("textureSize", type);
else if (op == "texelFetch")
return join("texelFetch", type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
{
SPIRV_CROSS_THROW(join("Unsupported legacy texture op: ", op));
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
bool CompilerGLSL::to_trivial_mix_op(const SPIRType &type, string &op, uint32_t left, uint32_t right, uint32_t lerp)
{
auto *cleft = maybe_get<SPIRConstant>(left);
auto *cright = maybe_get<SPIRConstant>(right);
auto &lerptype = expression_type(lerp);
// If our targets aren't constants, we cannot use construction.
if (!cleft || !cright)
return false;
// If our targets are spec constants, we cannot use construction.
if (cleft->specialization || cright->specialization)
return false;
Handle SPIR-V 1.4 selection constructs. Fix bug in to_trivial_mix_op, where we made a pre-1.4 assumption that component count of selector is equal to value component count.
2021-06-28 09:10:55 +00:00
auto &value_type = get<SPIRType>(cleft->constant_type);
if (lerptype.basetype != SPIRType::Boolean)
return false;
if (value_type.basetype == SPIRType::Struct || is_array(value_type))
return false;
if (!backend.use_constructor_splatting && value_type.vecsize != lerptype.vecsize)
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
return false;
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
// Only valid way in SPIR-V 1.4 to use matrices in select is a scalar select.
// matrix(scalar) constructor fills in diagnonals, so gets messy very quickly.
// Just avoid this case.
if (value_type.columns > 1)
return false;
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
// If our bool selects between 0 and 1, we can cast from bool instead, making our trivial constructor.
Handle SPIR-V 1.4 selection constructs. Fix bug in to_trivial_mix_op, where we made a pre-1.4 assumption that component count of selector is equal to value component count.
2021-06-28 09:10:55 +00:00
bool ret = true;
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
for (uint32_t row = 0; ret && row < value_type.vecsize; row++)
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
{
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
switch (type.basetype)
Handle SPIR-V 1.4 selection constructs. Fix bug in to_trivial_mix_op, where we made a pre-1.4 assumption that component count of selector is equal to value component count.
2021-06-28 09:10:55 +00:00
{
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
case SPIRType::Short:
case SPIRType::UShort:
ret = cleft->scalar_u16(0, row) == 0 && cright->scalar_u16(0, row) == 1;
break;
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
case SPIRType::Int:
case SPIRType::UInt:
ret = cleft->scalar(0, row) == 0 && cright->scalar(0, row) == 1;
break;
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
case SPIRType::Half:
ret = cleft->scalar_f16(0, row) == 0.0f && cright->scalar_f16(0, row) == 1.0f;
break;
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
case SPIRType::Float:
ret = cleft->scalar_f32(0, row) == 0.0f && cright->scalar_f32(0, row) == 1.0f;
break;
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
case SPIRType::Double:
ret = cleft->scalar_f64(0, row) == 0.0 && cright->scalar_f64(0, row) == 1.0;
break;
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
case SPIRType::Int64:
case SPIRType::UInt64:
ret = cleft->scalar_u64(0, row) == 0 && cright->scalar_u64(0, row) == 1;
break;
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
Test behavior around OpSelect with matrices.
2021-10-13 13:52:04 +00:00
default:
ret = false;
break;
Handle SPIR-V 1.4 selection constructs. Fix bug in to_trivial_mix_op, where we made a pre-1.4 assumption that component count of selector is equal to value component count.
2021-06-28 09:10:55 +00:00
}
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
}
if (ret)
op = type_to_glsl_constructor(type);
return ret;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Support ternary expressions in OpSpecConstantOp.
2018-06-25 07:48:17 +00:00
string CompilerGLSL::to_ternary_expression(const SPIRType &restype, uint32_t select, uint32_t true_value,
uint32_t false_value)
{
string expr;
auto &lerptype = expression_type(select);
if (lerptype.vecsize == 1)
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
expr = join(to_enclosed_expression(select), " ? ", to_enclosed_pointer_expression(true_value), " : ",
to_enclosed_pointer_expression(false_value));
Support ternary expressions in OpSpecConstantOp.
2018-06-25 07:48:17 +00:00
else
{
auto swiz = [this](uint32_t expression, uint32_t i) { return to_extract_component_expression(expression, i); };
expr = type_to_glsl_constructor(restype);
expr += "(";
for (uint32_t i = 0; i < restype.vecsize; i++)
{
expr += swiz(select, i);
expr += " ? ";
expr += swiz(true_value, i);
expr += " : ";
expr += swiz(false_value, i);
if (i + 1 < restype.vecsize)
expr += ", ";
}
expr += ")";
}
return expr;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
void CompilerGLSL::emit_mix_op(uint32_t result_type, uint32_t id, uint32_t left, uint32_t right, uint32_t lerp)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &lerptype = expression_type(lerp);
auto &restype = get<SPIRType>(result_type);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// If this results in a variable pointer, assume it may be written through.
if (restype.pointer)
{
register_write(left);
register_write(right);
}
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
string mix_op;
MSL: Use the select() function for OpSelect. This significantly improves codegen for vector `OpSelect` in MSL.
2019-07-11 04:46:40 +00:00
bool has_boolean_mix = *backend.boolean_mix_function &&
Avoid boolean mix in HLSL. Update glslang travis checkout as boolean mix support was broken on that commit.
2017-05-04 08:28:30 +00:00
((options.es && options.version >= 310) || (!options.es && options.version >= 450));
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
bool trivial_mix = to_trivial_mix_op(restype, mix_op, left, right, lerp);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Update glslang to latest on Travis. Fix a lingering bug with OpSelect and boolean mix().
2017-02-11 09:52:34 +00:00
// Cannot use boolean mix when the lerp argument is just one boolean,
// fall back to regular trinary statements.
if (lerptype.vecsize == 1)
has_boolean_mix = false;
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
// If we can reduce the mix to a simple cast, do so.
// This helps for cases like int(bool), uint(bool) which is implemented with
// OpSelect bool 1 0.
if (trivial_mix)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Implement OpSpecConstantOp. The details here get quite hairy, and it's not complete as not all functionality is implemented in glslang yet.
2016-10-03 13:54:02 +00:00
emit_unary_func_op(result_type, id, lerp, mix_op.c_str());
}
else if (!has_boolean_mix && lerptype.basetype == SPIRType::Boolean)
{
// Boolean mix not supported on desktop without extension.
// Was added in OpenGL 4.5 with ES 3.1 compat.
//
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Could use GL_EXT_shader_integer_mix on desktop at least,
// but Apple doesn't support it. :(
// Just implement it as ternary expressions.
Support ternary expressions in OpSpecConstantOp.
2018-06-25 07:48:17 +00:00
auto expr = to_ternary_expression(get<SPIRType>(result_type), lerp, right, left);
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
emit_op(result_type, id, expr, should_forward(left) && should_forward(right) && should_forward(lerp));
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(id, left);
inherit_expression_dependencies(id, right);
inherit_expression_dependencies(id, lerp);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
MSL: Use the select() function for OpSelect. This significantly improves codegen for vector `OpSelect` in MSL.
2019-07-11 04:46:40 +00:00
else if (lerptype.basetype == SPIRType::Boolean)
emit_trinary_func_op(result_type, id, left, right, lerp, backend.boolean_mix_function);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
emit_trinary_func_op(result_type, id, left, right, lerp, "mix");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
string CompilerGLSL::to_combined_image_sampler(VariableID image_id, VariableID samp_id)
Track sampler ID in Meta for OpSampledImage objects. Add virtual CompilerGLSL emit_sampled_image_op function for OpSampledImage. Under MSL, set sampler ID for local OpSampledImage objects and extract it when emitting sampler.
2016-04-24 01:47:41 +00:00
{
Combined array of images is starting to work ...
2018-04-23 09:52:05 +00:00
// Keep track of the array indices we have used to load the image.
// We'll need to use the same array index into the combined image sampler array.
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
auto image_expr = to_non_uniform_aware_expression(image_id);
Combined array of images is starting to work ...
2018-04-23 09:52:05 +00:00
string array_expr;
auto array_index = image_expr.find_first_of('[');
if (array_index != string::npos)
array_expr = image_expr.substr(array_index, string::npos);
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
auto &args = current_function->arguments;
// For GLSL and ESSL targets, we must enumerate all possible combinations for sampler2D(texture2D, sampler) and redirect
// all possible combinations into new sampler2D uniforms.
auto *image = maybe_get_backing_variable(image_id);
auto *samp = maybe_get_backing_variable(samp_id);
if (image)
image_id = image->self;
if (samp)
samp_id = samp->self;
auto image_itr = find_if(begin(args), end(args),
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
[image_id](const SPIRFunction::Parameter &param) { return image_id == param.id; });
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
auto sampler_itr = find_if(begin(args), end(args),
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
[samp_id](const SPIRFunction::Parameter &param) { return samp_id == param.id; });
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
if (image_itr != end(args) || sampler_itr != end(args))
{
// If any parameter originates from a parameter, we will find it in our argument list.
Consistently use "image" nomenclature for separate images.
2016-09-11 11:47:06 +00:00
bool global_image = image_itr == end(args);
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
bool global_sampler = sampler_itr == end(args);
Fix -Wshorten-64-to-32 warnings.
2019-09-17 08:16:47 +00:00
VariableID iid = global_image ? image_id : VariableID(uint32_t(image_itr - begin(args)));
VariableID sid = global_sampler ? samp_id : VariableID(uint32_t(sampler_itr - begin(args)));
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
auto &combined = current_function->combined_parameters;
auto itr = find_if(begin(combined), end(combined), [=](const SPIRFunction::CombinedImageSamplerParameter &p) {
Consistently use "image" nomenclature for separate images.
2016-09-11 11:47:06 +00:00
return p.global_image == global_image && p.global_sampler == global_sampler && p.image_id == iid &&
p.sampler_id == sid;
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
});
if (itr != end(combined))
Combined array of images is starting to work ...
2018-04-23 09:52:05 +00:00
return to_expression(itr->id) + array_expr;
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
else
{
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Cannot find mapping for combined sampler parameter, was "
"build_combined_image_samplers() used "
"before compile() was called?");
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
}
Begin redirecting separate params to other params.
2016-09-11 10:05:20 +00:00
}
Basic combined image sampler emulation hooked up.
2016-09-10 15:48:52 +00:00
else
{
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
// For global sampler2D, look directly at the global remapping table.
auto &mapping = combined_image_samplers;
auto itr = find_if(begin(mapping), end(mapping), [image_id, samp_id](const CombinedImageSampler &combined) {
return combined.image_id == image_id && combined.sampler_id == samp_id;
});
Basic combined image sampler emulation hooked up.
2016-09-10 15:48:52 +00:00
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
if (itr != end(combined_image_samplers))
Combined array of images is starting to work ...
2018-04-23 09:52:05 +00:00
return to_expression(itr->combined_id) + array_expr;
Basic combined image sampler emulation hooked up.
2016-09-10 15:48:52 +00:00
else
Trace usage of image/sampler variants through calls.
2016-09-10 19:52:22 +00:00
{
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Cannot find mapping for combined sampler, was build_combined_image_samplers() used "
"before compile() was called?");
Trace usage of image/sampler variants through calls.
2016-09-10 19:52:22 +00:00
}
Basic combined image sampler emulation hooked up.
2016-09-10 15:48:52 +00:00
}
Track sampler ID in Meta for OpSampledImage objects. Add virtual CompilerGLSL emit_sampled_image_op function for OpSampledImage. Under MSL, set sampler ID for local OpSampledImage objects and extract it when emitting sampler.
2016-04-24 01:47:41 +00:00
}
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
bool CompilerGLSL::is_supported_subgroup_op_in_opengl(spv::Op op, const uint32_t *ops)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
switch (op)
{
case OpGroupNonUniformElect:
case OpGroupNonUniformBallot:
case OpGroupNonUniformBallotFindLSB:
case OpGroupNonUniformBallotFindMSB:
case OpGroupNonUniformBroadcast:
case OpGroupNonUniformBroadcastFirst:
case OpGroupNonUniformAll:
case OpGroupNonUniformAny:
case OpGroupNonUniformAllEqual:
case OpControlBarrier:
case OpMemoryBarrier:
case OpGroupNonUniformBallotBitCount:
case OpGroupNonUniformBallotBitExtract:
case OpGroupNonUniformInverseBallot:
return true;
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
case OpGroupNonUniformIAdd:
GLSL: Support KHR_subgroup_arithmetic FAdd Support NV workarounds for FAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-02 07:45:25 +00:00
case OpGroupNonUniformFAdd:
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
case OpGroupNonUniformIMul:
case OpGroupNonUniformFMul:
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
{
const GroupOperation operation = static_cast<GroupOperation>(ops[3]);
if (operation == GroupOperationReduce || operation == GroupOperationInclusiveScan ||
operation == GroupOperationExclusiveScan)
{
return true;
}
GLSL: Address review comments Fix a warning and some format issues
2023-05-01 11:24:33 +00:00
else
{
return false;
}
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
}
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
default:
return false;
}
}
Track sampler ID in Meta for OpSampledImage objects. Add virtual CompilerGLSL emit_sampled_image_op function for OpSampledImage. Under MSL, set sampler ID for local OpSampledImage objects and extract it when emitting sampler.
2016-04-24 01:47:41 +00:00
void CompilerGLSL::emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id)
{
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
if (options.vulkan_semantics && combined_image_samplers.empty())
{
emit_binary_func_op(result_type, result_id, image_id, samp_id,
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
type_to_glsl(get<SPIRType>(result_type), result_id).c_str());
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
}
else
Fix case where SampledImage would get flushed to temporary.
2018-04-27 07:34:13 +00:00
{
// Make sure to suppress usage tracking. It is illegal to create temporaries of opaque types.
emit_op(result_type, result_id, to_combined_image_sampler(image_id, samp_id), true, true);
}
Vulkan GLSL: Support disabling samplerless texture function EXT. Some platforms support Vulkan GLSL, but not this extension apparently ...
2019-07-25 09:07:14 +00:00
// Make sure to suppress usage tracking and any expression invalidation.
// It is illegal to create temporaries of opaque types.
forwarded_temporaries.erase(result_id);
Track sampler ID in Meta for OpSampledImage objects. Add virtual CompilerGLSL emit_sampled_image_op function for OpSampledImage. Under MSL, set sampler ID for local OpSampledImage objects and extract it when emitting sampler.
2016-04-24 01:47:41 +00:00
}
MSL: Fix textures which are sampled and compared against. depth2d in MSL only returns float, not float4, even for normal sampling. We need to conditionally remap-swizzle back to float4.
2019-02-22 11:02:11 +00:00
static inline bool image_opcode_is_sample_no_dref(Op op)
{
switch (op)
{
case OpImageSampleExplicitLod:
case OpImageSampleImplicitLod:
case OpImageSampleProjExplicitLod:
case OpImageSampleProjImplicitLod:
case OpImageFetch:
case OpImageRead:
case OpImageSparseSampleExplicitLod:
case OpImageSparseSampleImplicitLod:
case OpImageSparseSampleProjExplicitLod:
case OpImageSparseSampleProjImplicitLod:
case OpImageSparseFetch:
case OpImageSparseRead:
return true;
default:
return false;
}
}
Run format_all.sh.
2020-07-01 09:42:58 +00:00
void CompilerGLSL::emit_sparse_feedback_temporaries(uint32_t result_type_id, uint32_t id, uint32_t &feedback_id,
uint32_t &texel_id)
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
{
// Need to allocate two temporaries.
if (options.es)
SPIRV_CROSS_THROW("Sparse texture feedback is not supported on ESSL.");
require_extension_internal("GL_ARB_sparse_texture2");
auto &temps = extra_sub_expressions[id];
if (temps == 0)
temps = ir.increase_bound_by(2);
feedback_id = temps + 0;
texel_id = temps + 1;
auto &return_type = get<SPIRType>(result_type_id);
if (return_type.basetype != SPIRType::Struct || return_type.member_types.size() != 2)
SPIRV_CROSS_THROW("Invalid return type for sparse feedback.");
emit_uninitialized_temporary(return_type.member_types[0], feedback_id);
emit_uninitialized_temporary(return_type.member_types[1], texel_id);
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
uint32_t CompilerGLSL::get_sparse_feedback_texel_id(uint32_t id) const
{
auto itr = extra_sub_expressions.find(id);
if (itr == extra_sub_expressions.end())
return 0;
else
return itr->second + 1;
}
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
void CompilerGLSL::emit_texture_op(const Instruction &i, bool sparse)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto *ops = stream(i);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto op = static_cast<Op>(i.op);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<uint32_t> inherited_expressions;
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
uint32_t result_type_id = ops[0];
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t id = ops[1];
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
auto &return_type = get<SPIRType>(result_type_id);
uint32_t sparse_code_id = 0;
uint32_t sparse_texel_id = 0;
if (sparse)
emit_sparse_feedback_temporaries(result_type_id, id, sparse_code_id, sparse_texel_id);
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
bool forward = false;
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
string expr = to_texture_op(i, sparse, &forward, inherited_expressions);
if (sparse)
{
statement(to_expression(sparse_code_id), " = ", expr, ";");
Run format_all.sh.
2020-07-01 09:42:58 +00:00
expr = join(type_to_glsl(return_type), "(", to_expression(sparse_code_id), ", ", to_expression(sparse_texel_id),
")");
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
forward = true;
inherited_expressions.clear();
}
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
emit_op(result_type_id, id, expr, forward);
for (auto &inherit : inherited_expressions)
inherit_expression_dependencies(id, inherit);
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
// Do not register sparse ops as control dependent as they are always lowered to a temporary.
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
switch (op)
{
case OpImageSampleDrefImplicitLod:
case OpImageSampleImplicitLod:
case OpImageSampleProjImplicitLod:
case OpImageSampleProjDrefImplicitLod:
register_control_dependent_expression(id);
break;
default:
break;
}
}
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
std::string CompilerGLSL::to_texture_op(const Instruction &i, bool sparse, bool *forward,
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
SmallVector<uint32_t> &inherited_expressions)
{
auto *ops = stream(i);
auto op = static_cast<Op>(i.op);
uint32_t length = i.length;
uint32_t result_type_id = ops[0];
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
VariableID img = ops[2];
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t coord = ops[3];
uint32_t dref = 0;
uint32_t comp = 0;
bool gather = false;
bool proj = false;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
bool fetch = false;
GLSL: Emit nonuniformEXT in correct place for late-combined samplers. Need to emit nonuniformEXT(sampler2D()) since constructor expressions in Vulkan GLSL do not propgate the nonuniform qualifier.
2020-12-07 12:00:15 +00:00
bool nonuniform_expression = false;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
const uint32_t *opt = nullptr;
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
auto &result_type = get<SPIRType>(result_type_id);
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherited_expressions.push_back(coord);
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
if (has_decoration(img, DecorationNonUniform) && !maybe_get_backing_variable(img))
nonuniform_expression = true;
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (op)
{
case OpImageSampleDrefImplicitLod:
case OpImageSampleDrefExplicitLod:
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
case OpImageSparseSampleDrefImplicitLod:
case OpImageSparseSampleDrefExplicitLod:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
dref = ops[4];
opt = &ops[5];
length -= 5;
break;
case OpImageSampleProjDrefImplicitLod:
case OpImageSampleProjDrefExplicitLod:
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
case OpImageSparseSampleProjDrefImplicitLod:
case OpImageSparseSampleProjDrefExplicitLod:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
dref = ops[4];
opt = &ops[5];
length -= 5;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
proj = true;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpImageDrefGather:
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
case OpImageSparseDrefGather:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
dref = ops[4];
opt = &ops[5];
length -= 5;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
gather = true;
GLSL: Add error checking and extension fallback for textureGather
2020-11-06 23:01:57 +00:00
if (options.es && options.version < 310)
SPIRV_CROSS_THROW("textureGather requires ESSL 310.");
else if (!options.es && options.version < 400)
SPIRV_CROSS_THROW("textureGather with depth compare requires GLSL 400.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpImageGather:
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
case OpImageSparseGather:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
comp = ops[4];
opt = &ops[5];
length -= 5;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
gather = true;
GLSL: Add error checking and extension fallback for textureGather
2020-11-06 23:01:57 +00:00
if (options.es && options.version < 310)
SPIRV_CROSS_THROW("textureGather requires ESSL 310.");
else if (!options.es && options.version < 400)
{
if (!expression_is_constant_null(comp))
SPIRV_CROSS_THROW("textureGather with component requires GLSL 400.");
require_extension_internal("GL_ARB_texture_gather");
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
break;
case OpImageFetch:
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
case OpImageSparseFetch:
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
case OpImageRead: // Reads == fetches in Metal (other langs will not get here)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
opt = &ops[4];
length -= 4;
fetch = true;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpImageSampleProjImplicitLod:
case OpImageSampleProjExplicitLod:
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
case OpImageSparseSampleProjImplicitLod:
case OpImageSparseSampleProjExplicitLod:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
opt = &ops[4];
length -= 4;
proj = true;
break;
default:
opt = &ops[4];
length -= 4;
break;
}
CompilerMSL map many GLSL functions to MSL functions. Add bool members is_read and is_written to SPIRType::Image. Output correct texture read/write access by marking whether textures are read from and written to by the shader. Override bitcast_glsl_op() to use Metal as_type<type> functions. Add implementations of SPIR-V functions inverse(), degrees() & radians(). Map inverseSqrt() to rsqrt(). Map roundEven() to rint(). GLSL functions imageSize() and textureSize() map to equivalent expression using MSL get_width() & get_height() functions. Map several SPIR-V integer bitfield functions to MSL equivalents. Map SPIR-V atomic functions to MSL equivalents. Map texture packing and unpacking functions to MSL equivalents. Refactor existing, and add new, image query functions. Reorganize header lines into includes and pragmas. Simplify type_to_glsl() logic. Add MSL test case vert/functions.vert for added function implementations. Add MSL test case comp/atomic.comp for added function implementations. test_shaders.py use macOS compilation for MSL shader compilation validations.
2017-05-19 22:14:08 +00:00
// Bypass pointers because we need the real image struct
auto &type = expression_type(img);
auto &imgtype = get<SPIRType>(type.self);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t coord_components = 0;
switch (imgtype.image.dim)
{
case spv::Dim1D:
coord_components = 1;
break;
case spv::Dim2D:
coord_components = 2;
break;
case spv::Dim3D:
coord_components = 3;
break;
case spv::DimCube:
coord_components = 3;
break;
case spv::DimBuffer:
coord_components = 1;
break;
default:
coord_components = 2;
break;
}
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
if (dref)
inherited_expressions.push_back(dref);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (proj)
coord_components++;
if (imgtype.image.arrayed)
coord_components++;
uint32_t bias = 0;
uint32_t lod = 0;
uint32_t grad_x = 0;
uint32_t grad_y = 0;
uint32_t coffset = 0;
uint32_t offset = 0;
uint32_t coffsets = 0;
uint32_t sample = 0;
MSL: Support MinLod operand.
2019-06-11 09:10:16 +00:00
uint32_t minlod = 0;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
uint32_t flags = 0;
if (length)
{
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
flags = *opt++;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
length--;
}
Non-functional: Update formatting.
2016-05-23 11:30:02 +00:00
auto test = [&](uint32_t &v, uint32_t flag) {
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (length && (flags & flag))
{
v = *opt++;
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherited_expressions.push_back(v);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
length--;
}
};
test(bias, ImageOperandsBiasMask);
test(lod, ImageOperandsLodMask);
test(grad_x, ImageOperandsGradMask);
test(grad_y, ImageOperandsGradMask);
test(coffset, ImageOperandsConstOffsetMask);
test(offset, ImageOperandsOffsetMask);
test(coffsets, ImageOperandsConstOffsetsMask);
test(sample, ImageOperandsSampleMask);
MSL: Support MinLod operand.
2019-06-11 09:10:16 +00:00
test(minlod, ImageOperandsMinLodMask);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
TextureFunctionBaseArguments base_args = {};
base_args.img = img;
base_args.imgtype = &imgtype;
base_args.is_fetch = fetch != 0;
base_args.is_gather = gather != 0;
base_args.is_proj = proj != 0;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string expr;
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
TextureFunctionNameArguments name_args = {};
name_args.base = base_args;
name_args.has_array_offsets = coffsets != 0;
name_args.has_offset = coffset != 0 || offset != 0;
name_args.has_grad = grad_x != 0 || grad_y != 0;
name_args.has_dref = dref != 0;
name_args.is_sparse_feedback = sparse;
name_args.has_min_lod = minlod != 0;
name_args.lod = lod;
expr += to_function_name(name_args);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
expr += "(";
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
uint32_t sparse_texel_id = 0;
if (sparse)
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
sparse_texel_id = get_sparse_feedback_texel_id(ops[1]);
TextureFunctionArguments args = {};
args.base = base_args;
args.coord = coord;
args.coord_components = coord_components;
args.dref = dref;
args.grad_x = grad_x;
args.grad_y = grad_y;
args.lod = lod;
MSL: Support ConstOffsets on image gather. - Add TextureFunctionArguments::has_array_offsets. - Add support functions spvGatherConstOffsets() & spvGatherCompareConstOffsets(). - Add SPVFuncImpl::SPVFuncImplGatherConstOffsets & SPVFuncImplGatherCompareConstOffsets. - Add unit tests.
2024-05-20 16:06:58 +00:00
args.has_array_offsets = coffsets != 0;
GLSL: Handle textureGatherOffsets properly. We forgot to pass down the offset ID, clean up coffset vs offset jank while we're at it.
2023-01-12 15:24:49 +00:00
if (coffsets)
args.offset = coffsets;
else if (coffset)
args.offset = coffset;
else
args.offset = offset;
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
args.bias = bias;
args.component = comp;
args.sample = sample;
args.sparse_texel = sparse_texel_id;
args.min_lod = minlod;
GLSL: Emit nonuniformEXT in correct place for late-combined samplers. Need to emit nonuniformEXT(sampler2D()) since constructor expressions in Vulkan GLSL do not propgate the nonuniform qualifier.
2020-12-07 12:00:15 +00:00
args.nonuniform_expression = nonuniform_expression;
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
expr += to_function_args(args, forward);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
expr += ")";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
GLSL: Implement 1D texture emulation for ES. ES does not support 1D images at all. Fake it by promoting 1D images to 2D.
2022-05-27 09:51:34 +00:00
// texture(samplerXShadow) returns float. shadowX() returns vec4, but only in desktop GLSL. Swizzle here.
if (is_legacy() && !options.es && is_depth_image(imgtype, img))
Added support for shadowXY() sample instructions in legacy GLSL
2018-06-22 07:28:40 +00:00
expr += ".r";
MSL: Fix textures which are sampled and compared against. depth2d in MSL only returns float, not float4, even for normal sampling. We need to conditionally remap-swizzle back to float4.
2019-02-22 11:02:11 +00:00
// Sampling from a texture which was deduced to be a depth image, might actually return 1 component here.
// Remap back to 4 components as sampling opcodes expect.
MSL: Fix depth2d 4-component fixup. Need to look at the backing image for the image. We might have found diverging use at the image variable level, not just expression level.
2019-04-03 08:24:22 +00:00
if (backend.comparison_image_samples_scalar && image_opcode_is_sample_no_dref(op))
{
bool image_is_depth = false;
const auto *combined = maybe_get<SPIRCombinedImageSampler>(img);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
VariableID image_id = combined ? combined->image : img;
MSL: Fix depth2d 4-component fixup. Need to look at the backing image for the image. We might have found diverging use at the image variable level, not just expression level.
2019-04-03 08:24:22 +00:00
Separate (partially) the tracking of depth images from depth compare ops. SPIR-V allows an image to be marked as a depth image, but with a non-depth format. Such images should be read or sampled as vectors instead of scalars, except when they are subject to compare operations. Don't mark an OpSampledImage as using a compare operation just because the image contains a depth marker. Instead, require that a compare operation is actually used on that image. Compiler::image_is_comparison() was really testing whether an image is a depth image, since it incorporates the depth marker. Rename that function to is_depth_image(), to clarify what it is really testing. In Compiler::is_depth_image(), do not treat an image as a depth image if it has been explicitly marked with a color format, unless the image is subject to compare operations. In CompilerMSL::to_function_name(), test for compare operations specifically, rather than assuming them from the depth-image marker. CompilerGLSL and CompilerMSL still contain a number of internal tests that use is_depth_image() both for testing for a depth image, and for testing whether compare operations are being used. I've left these as they are for now, but these should be cleaned up at some point. Add unit tests for fetch/sample depth images with color formats and no compare ops.
2021-11-08 20:59:45 +00:00
if (combined && is_depth_image(imgtype, combined->image))
MSL: Fix depth2d 4-component fixup. Need to look at the backing image for the image. We might have found diverging use at the image variable level, not just expression level.
2019-04-03 08:24:22 +00:00
image_is_depth = true;
Separate (partially) the tracking of depth images from depth compare ops. SPIR-V allows an image to be marked as a depth image, but with a non-depth format. Such images should be read or sampled as vectors instead of scalars, except when they are subject to compare operations. Don't mark an OpSampledImage as using a compare operation just because the image contains a depth marker. Instead, require that a compare operation is actually used on that image. Compiler::image_is_comparison() was really testing whether an image is a depth image, since it incorporates the depth marker. Rename that function to is_depth_image(), to clarify what it is really testing. In Compiler::is_depth_image(), do not treat an image as a depth image if it has been explicitly marked with a color format, unless the image is subject to compare operations. In CompilerMSL::to_function_name(), test for compare operations specifically, rather than assuming them from the depth-image marker. CompilerGLSL and CompilerMSL still contain a number of internal tests that use is_depth_image() both for testing for a depth image, and for testing whether compare operations are being used. I've left these as they are for now, but these should be cleaned up at some point. Add unit tests for fetch/sample depth images with color formats and no compare ops.
2021-11-08 20:59:45 +00:00
else if (is_depth_image(imgtype, img))
MSL: Fix depth2d 4-component fixup. Need to look at the backing image for the image. We might have found diverging use at the image variable level, not just expression level.
2019-04-03 08:24:22 +00:00
image_is_depth = true;
// We must also check the backing variable for the image.
// We might have loaded an OpImage, and used that handle for two different purposes.
// Once with comparison, once without.
auto *image_variable = maybe_get_backing_variable(image_id);
Separate (partially) the tracking of depth images from depth compare ops. SPIR-V allows an image to be marked as a depth image, but with a non-depth format. Such images should be read or sampled as vectors instead of scalars, except when they are subject to compare operations. Don't mark an OpSampledImage as using a compare operation just because the image contains a depth marker. Instead, require that a compare operation is actually used on that image. Compiler::image_is_comparison() was really testing whether an image is a depth image, since it incorporates the depth marker. Rename that function to is_depth_image(), to clarify what it is really testing. In Compiler::is_depth_image(), do not treat an image as a depth image if it has been explicitly marked with a color format, unless the image is subject to compare operations. In CompilerMSL::to_function_name(), test for compare operations specifically, rather than assuming them from the depth-image marker. CompilerGLSL and CompilerMSL still contain a number of internal tests that use is_depth_image() both for testing for a depth image, and for testing whether compare operations are being used. I've left these as they are for now, but these should be cleaned up at some point. Add unit tests for fetch/sample depth images with color formats and no compare ops.
2021-11-08 20:59:45 +00:00
if (image_variable && is_depth_image(get<SPIRType>(image_variable->basetype), image_variable->self))
MSL: Fix depth2d 4-component fixup. Need to look at the backing image for the image. We might have found diverging use at the image variable level, not just expression level.
2019-04-03 08:24:22 +00:00
image_is_depth = true;
if (image_is_depth)
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
expr = remap_swizzle(result_type, 1, expr);
}
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
if (!sparse && !backend.support_small_type_sampling_result && result_type.width < 32)
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
{
// Just value cast (narrowing) to expected type since we cannot rely on narrowing to work automatically.
// Hopefully compiler picks this up and converts the texturing instruction to the appropriate precision.
expr = join(type_to_glsl_constructor(result_type), "(", expr, ")");
MSL: Fix textures which are sampled and compared against. depth2d in MSL only returns float, not float4, even for normal sampling. We need to conditionally remap-swizzle back to float4.
2019-02-22 11:02:11 +00:00
}
MSL: Fix image load/store for short vectors. Same fixes as for GLSL.
2019-01-17 13:53:42 +00:00
// Deals with reads from MSL. We might need to downconvert to fewer components.
if (op == OpImageRead)
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
expr = remap_swizzle(result_type, 4, expr);
MSL: Fix image load/store for short vectors. Same fixes as for GLSL.
2019-01-17 13:53:42 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
return expr;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
}
MSL: Workaround missing gradient2d() for sampler_compare.
2019-01-07 09:01:00 +00:00
bool CompilerGLSL::expression_is_constant_null(uint32_t id) const
{
auto *c = maybe_get<SPIRConstant>(id);
if (!c)
return false;
return c->constant_is_null();
}
MSL: Deal with loading non-value-type arrays.
2020-06-18 10:46:39 +00:00
bool CompilerGLSL::expression_is_non_value_type_array(uint32_t ptr)
{
auto &type = expression_type(ptr);
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
if (!is_array(get_pointee_type(type)))
MSL: Deal with loading non-value-type arrays.
2020-06-18 10:46:39 +00:00
return false;
if (!backend.array_is_value_type)
return true;
auto *var = maybe_get_backing_variable(ptr);
if (!var)
return false;
auto &backed_type = get<SPIRType>(var->basetype);
MSL: Handle constant construct of block-like array types. Need this to be context sensitive, since array of block-like struct is template, but struct of block-like array is C-style. Also, test a mix and match, so we have constant array of block-like struct with array inside. :v
2022-01-17 16:33:57 +00:00
return !backend.array_is_value_type_in_buffer_blocks && backed_type.basetype == SPIRType::Struct &&
MSL: Deal with loading non-value-type arrays.
2020-06-18 10:46:39 +00:00
has_member_decoration(backed_type.self, 0, DecorationOffset);
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
// Returns the function name for a texture sampling function for the specified image and sampling characteristics.
// For some subclasses, the function is a method on the specified image.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
string CompilerGLSL::to_function_name(const TextureFunctionNameArguments &args)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.has_min_lod)
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
{
if (options.es)
SPIRV_CROSS_THROW("Sparse residency is not supported in ESSL.");
require_extension_internal("GL_ARB_sparse_texture_clamp");
}
MSL: Support MinLod operand.
2019-06-11 09:10:16 +00:00
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
string fname;
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
auto &imgtype = *args.base.imgtype;
VariableID tex = args.base.img;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Support SampleCmpLevelZero on cubes as well.
2017-07-24 07:28:24 +00:00
// textureLod on sampler2DArrayShadow and samplerCubeShadow does not exist in GLSL for some reason.
Implement workaround for textureLod on 2D array shadow. This does not exist in GLSL, but it exists in HLSL if LOD == 0.0.
2017-06-23 07:44:41 +00:00
// To emulate this, we will have to use textureGrad with a constant gradient of 0.
// The workaround will assert that the LOD is in fact constant 0, or we cannot emit correct code.
Support SampleCmpLevelZero on cubes as well.
2017-07-24 07:28:24 +00:00
// This happens for HLSL SampleCmpLevelZero on Texture2DArray and TextureCube.
Implement workaround for textureLod on 2D array shadow. This does not exist in GLSL, but it exists in HLSL if LOD == 0.0.
2017-06-23 07:44:41 +00:00
bool workaround_lod_array_shadow_as_grad = false;
Support SampleCmpLevelZero on cubes as well.
2017-07-24 07:28:24 +00:00
if (((imgtype.image.arrayed && imgtype.image.dim == Dim2D) || imgtype.image.dim == DimCube) &&
GLSL: Don't apply Grad LOD workarounds for fetch.
2022-05-13 13:47:22 +00:00
is_depth_image(imgtype, tex) && args.lod && !args.base.is_fetch)
Implement workaround for textureLod on 2D array shadow. This does not exist in GLSL, but it exists in HLSL if LOD == 0.0.
2017-06-23 07:44:41 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (!expression_is_constant_null(args.lod))
MSL: Workaround missing gradient2d() for sampler_compare.
2019-01-07 09:01:00 +00:00
{
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("textureLod on sampler2DArrayShadow is not constant 0.0. This cannot be "
"expressed in GLSL.");
MSL: Workaround missing gradient2d() for sampler_compare.
2019-01-07 09:01:00 +00:00
}
Implement workaround for textureLod on 2D array shadow. This does not exist in GLSL, but it exists in HLSL if LOD == 0.0.
2017-06-23 07:44:41 +00:00
workaround_lod_array_shadow_as_grad = true;
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.is_sparse_feedback)
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
fname += "sparse";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
fname += args.is_sparse_feedback ? "TexelFetch" : "texelFetch";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
fname += args.is_sparse_feedback ? "Texture" : "texture";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_gather)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
fname += "Gather";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.has_array_offsets)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
fname += "Offsets";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_proj)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
fname += "Proj";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.has_grad || workaround_lod_array_shadow_as_grad)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
fname += "Grad";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.lod != 0 && !workaround_lod_array_shadow_as_grad)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
fname += "Lod";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.has_offset)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
fname += "Offset";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
GLSL: Handle the rest of GL_ARB_sparse_texture_clamp. Missed these in initial sparse implementation.
2020-06-08 11:39:02 +00:00
if (args.has_min_lod)
fname += "Clamp";
if (args.is_sparse_feedback || args.has_min_lod)
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
fname += "ARB";
GLSL: Add error checking and extension fallback for textureGather
2020-11-06 23:01:57 +00:00
return (is_legacy() && !args.base.is_gather) ? legacy_tex_op(fname, imgtype, tex) : fname;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
std::string CompilerGLSL::convert_separate_image_to_expression(uint32_t id)
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
{
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
auto *var = maybe_get_backing_variable(id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
// If we are fetching from a plain OpTypeImage, we must combine with a dummy sampler in GLSL.
// In Vulkan GLSL, we can make use of the newer GL_EXT_samplerless_texture_functions.
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
if (var)
Add test for texelFetch without sampler.
2018-02-21 12:43:16 +00:00
{
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
auto &type = get<SPIRType>(var->basetype);
if (type.basetype == SPIRType::Image && type.image.sampled == 1 && type.image.dim != DimBuffer)
Add test for texelFetch without sampler.
2018-02-21 12:43:16 +00:00
{
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
if (options.vulkan_semantics)
{
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
if (dummy_sampler_id)
Vulkan GLSL: Support disabling samplerless texture function EXT. Some platforms support Vulkan GLSL, but not this extension apparently ...
2019-07-25 09:07:14 +00:00
{
// Don't need to consider Shadow state since the dummy sampler is always non-shadow.
auto sampled_type = type;
sampled_type.basetype = SPIRType::SampledImage;
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
return join(type_to_glsl(sampled_type), "(", to_non_uniform_aware_expression(id), ", ",
Fix severe performance issue with invariant expression invalidation. We were going down a tree of expressions multiple times and this caused an exponential explosion in time, which was not caught until recently. Fix this by blocking any traversal going through an ID more than one time. This fix overall improves performance by almost an order of magnitude on a particular test shader rather than slowing it down by ~75x.
2019-08-01 07:51:44 +00:00
to_expression(dummy_sampler_id), ")");
Vulkan GLSL: Support disabling samplerless texture function EXT. Some platforms support Vulkan GLSL, but not this extension apparently ...
2019-07-25 09:07:14 +00:00
}
else
{
// Newer glslang supports this extension to deal with texture2D as argument to texture functions.
require_extension_internal("GL_EXT_samplerless_texture_functions");
}
Add test for texelFetch without sampler.
2018-02-21 12:43:16 +00:00
}
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
else
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
{
if (!dummy_sampler_id)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Cannot find dummy sampler ID. Was "
"build_dummy_sampler_for_combined_images() called?");
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
return to_combined_image_sampler(id, dummy_sampler_id);
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
}
Add test for texelFetch without sampler.
2018-02-21 12:43:16 +00:00
}
}
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
return to_non_uniform_aware_expression(id);
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
}
// Returns the function args for a texture sampling function for the specified image and sampling characteristics.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
string CompilerGLSL::to_function_args(const TextureFunctionArguments &args, bool *p_forward)
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
VariableID img = args.base.img;
auto &imgtype = *args.base.imgtype;
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
string farg_str;
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.base.is_fetch)
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
farg_str = convert_separate_image_to_expression(img);
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
else
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
farg_str = to_non_uniform_aware_expression(img);
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
GLSL: Emit nonuniformEXT in correct place for late-combined samplers. Need to emit nonuniformEXT(sampler2D()) since constructor expressions in Vulkan GLSL do not propgate the nonuniform qualifier.
2020-12-07 12:00:15 +00:00
if (args.nonuniform_expression && farg_str.find_first_of('[') != string::npos)
{
// Only emit nonuniformEXT() wrapper if the underlying expression is arrayed in some way.
farg_str = join(backend.nonuniform_qualifier, "(", farg_str, ")");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
bool swizz_func = backend.swizzle_is_function;
Non-functional: Update formatting.
2016-05-23 11:30:02 +00:00
auto swizzle = [swizz_func](uint32_t comps, uint32_t in_comps) -> const char * {
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (comps == in_comps)
return "";
switch (comps)
{
case 1:
return ".x";
case 2:
return swizz_func ? ".xy()" : ".xy";
case 3:
return swizz_func ? ".xyz()" : ".xyz";
default:
return "";
}
};
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
bool forward = should_forward(args.coord);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// The IR can give us more components than we need, so chop them off as needed.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
auto swizzle_expr = swizzle(args.coord_components, expression_type(args.coord).vecsize);
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
// Only enclose the UV expression if needed.
Run format_all.sh.
2020-07-01 09:42:58 +00:00
auto coord_expr =
(*swizzle_expr == '\0') ? to_expression(args.coord) : (to_enclosed_expression(args.coord) + swizzle_expr);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
// texelFetch only takes int, not uint.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
auto &coord_type = expression_type(args.coord);
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
if (coord_type.basetype == SPIRType::UInt)
{
auto expected_type = coord_type;
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
expected_type.vecsize = args.coord_components;
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
expected_type.basetype = SPIRType::Int;
coord_expr = bitcast_expression(expected_type, coord_type.basetype, coord_expr);
}
Support SampleCmpLevelZero on cubes as well.
2017-07-24 07:28:24 +00:00
// textureLod on sampler2DArrayShadow and samplerCubeShadow does not exist in GLSL for some reason.
Implement workaround for textureLod on 2D array shadow. This does not exist in GLSL, but it exists in HLSL if LOD == 0.0.
2017-06-23 07:44:41 +00:00
// To emulate this, we will have to use textureGrad with a constant gradient of 0.
// The workaround will assert that the LOD is in fact constant 0, or we cannot emit correct code.
Support SampleCmpLevelZero on cubes as well.
2017-07-24 07:28:24 +00:00
// This happens for HLSL SampleCmpLevelZero on Texture2DArray and TextureCube.
Fix typo.
2017-06-23 07:50:01 +00:00
bool workaround_lod_array_shadow_as_grad =
Support SampleCmpLevelZero on cubes as well.
2017-07-24 07:28:24 +00:00
((imgtype.image.arrayed && imgtype.image.dim == Dim2D) || imgtype.image.dim == DimCube) &&
GLSL: Don't apply Grad LOD workarounds for fetch.
2022-05-13 13:47:22 +00:00
is_depth_image(imgtype, img) && args.lod != 0 && !args.base.is_fetch;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.dref)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.dref);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// SPIR-V splits dref and coordinate.
Run format_all.sh.
2020-07-01 09:42:58 +00:00
if (args.base.is_gather ||
args.coord_components == 4) // GLSL also splits the arguments in two. Same for textureGather.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.coord);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.dref);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
else if (args.base.is_proj)
Fix textureProj with shadow on GLSL.
2017-07-31 08:05:32 +00:00
{
// Have to reshuffle so we get vec4(coord, dref, proj), special case.
// Other shading languages splits up the arguments for coord and compare value like SPIR-V.
// The coordinate type for textureProj shadow is always vec4 even for sampler1DShadow.
farg_str += ", vec4(";
if (imgtype.image.dim == Dim1D)
{
// Could reuse coord_expr, but we will mess up the temporary usage checking.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_enclosed_expression(args.coord) + ".x";
Fix textureProj with shadow on GLSL.
2017-07-31 08:05:32 +00:00
farg_str += ", ";
farg_str += "0.0, ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.dref);
Fix textureProj with shadow on GLSL.
2017-07-31 08:05:32 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_enclosed_expression(args.coord) + ".y)";
Fix textureProj with shadow on GLSL.
2017-07-31 08:05:32 +00:00
}
else if (imgtype.image.dim == Dim2D)
{
// Could reuse coord_expr, but we will mess up the temporary usage checking.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_enclosed_expression(args.coord) + (swizz_func ? ".xy()" : ".xy");
Fix textureProj with shadow on GLSL.
2017-07-31 08:05:32 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.dref);
Fix textureProj with shadow on GLSL.
2017-07-31 08:05:32 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_enclosed_expression(args.coord) + ".z)";
Fix textureProj with shadow on GLSL.
2017-07-31 08:05:32 +00:00
}
else
SPIRV_CROSS_THROW("Invalid type for textureProj with shadow.");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
{
// Create a composite which merges coord/dref into a single vector.
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
auto type = expression_type(args.coord);
type.vecsize = args.coord_components + 1;
GLSL: Implement 1D texture emulation for ES. ES does not support 1D images at all. Fake it by promoting 1D images to 2D.
2022-05-27 09:51:34 +00:00
if (imgtype.image.dim == Dim1D && options.es)
type.vecsize++;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
farg_str += type_to_glsl_constructor(type);
farg_str += "(";
GLSL: Implement 1D texture emulation for ES. ES does not support 1D images at all. Fake it by promoting 1D images to 2D.
2022-05-27 09:51:34 +00:00
if (imgtype.image.dim == Dim1D && options.es)
{
if (imgtype.image.arrayed)
{
farg_str += enclose_expression(coord_expr) + ".x";
farg_str += ", 0.0, ";
farg_str += enclose_expression(coord_expr) + ".y";
}
else
{
farg_str += coord_expr;
farg_str += ", 0.0";
}
}
else
farg_str += coord_expr;
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.dref);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ")";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
else
{
GLSL: Implement 1D texture emulation for ES. ES does not support 1D images at all. Fake it by promoting 1D images to 2D.
2022-05-27 09:51:34 +00:00
if (imgtype.image.dim == Dim1D && options.es)
{
// Have to fake a second coordinate.
if (type_is_floating_point(coord_type))
{
// Cannot mix proj and array.
if (imgtype.image.arrayed || args.base.is_proj)
{
coord_expr = join("vec3(", enclose_expression(coord_expr), ".x, 0.0, ",
enclose_expression(coord_expr), ".y)");
}
else
coord_expr = join("vec2(", coord_expr, ", 0.0)");
}
else
{
if (imgtype.image.arrayed)
{
coord_expr = join("ivec3(", enclose_expression(coord_expr),
".x, 0, ",
enclose_expression(coord_expr), ".y)");
}
else
coord_expr = join("ivec2(", coord_expr, ", 0)");
}
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
farg_str += coord_expr;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.grad_x || args.grad_y)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.grad_x);
forward = forward && should_forward(args.grad_y);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.grad_x);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.grad_y);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.lod)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Implement workaround for textureLod on 2D array shadow. This does not exist in GLSL, but it exists in HLSL if LOD == 0.0.
2017-06-23 07:44:41 +00:00
if (workaround_lod_array_shadow_as_grad)
Prefer plain texture2D in legacy es vertex shaders WebGL supports lod texture funcs only in fragment shaders but SPIR-V supports only lod texture funcs in vertex shaders. This reverts calls which were forced (infered from using a 0 constant) to use an lod to plain calls in vertex shaders when using legacy es.
2017-03-23 08:55:32 +00:00
{
Implement workaround for textureLod on 2D array shadow. This does not exist in GLSL, but it exists in HLSL if LOD == 0.0.
2017-06-23 07:44:41 +00:00
// Implement textureGrad() instead. LOD == 0.0 is implemented as gradient of 0.0.
// Implementing this as plain texture() is not safe on some implementations.
Support SampleCmpLevelZero on cubes as well.
2017-07-24 07:28:24 +00:00
if (imgtype.image.dim == Dim2D)
farg_str += ", vec2(0.0), vec2(0.0)";
else if (imgtype.image.dim == DimCube)
farg_str += ", vec3(0.0), vec3(0.0)";
Implement workaround for textureLod on 2D array shadow. This does not exist in GLSL, but it exists in HLSL if LOD == 0.0.
2017-06-23 07:44:41 +00:00
}
else
{
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
forward = forward && should_forward(args.lod);
farg_str += ", ";
GLSL: Fix OpImageFetch with uint coordinates and LOD. Also fix some minor issues with too many coordinate dimensions in HLSL and GLSL.
2019-04-03 08:50:32 +00:00
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
// Lod expression for TexelFetch in GLSL must be int, and only int.
GLSL: Ensure correct signed integer type for more texture functions.
2022-02-16 10:13:29 +00:00
if (args.base.is_fetch && imgtype.image.dim != DimBuffer && !imgtype.image.ms)
farg_str += bitcast_expression(SPIRType::Int, args.lod);
GLSL: Fix support for textureLod in legacy vertex shaders
2020-11-05 21:55:44 +00:00
else
farg_str += to_expression(args.lod);
Prefer plain texture2D in legacy es vertex shaders WebGL supports lod texture funcs only in fragment shaders but SPIR-V supports only lod texture funcs in vertex shaders. This reverts calls which were forced (infered from using a 0 constant) to use an lod to plain calls in vertex shaders when using legacy es.
2017-03-23 08:55:32 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
else if (args.base.is_fetch && imgtype.image.dim != DimBuffer && !imgtype.image.ms)
Deal with OpImageFetch without explicit LOD.
2018-04-30 08:53:21 +00:00
{
// Lod argument is optional in OpImageFetch, but we require a LOD value, pick 0 as the default.
farg_str += ", 0";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
GLSL: Handle textureGatherOffsets properly. We forgot to pass down the offset ID, clean up coffset vs offset jank while we're at it.
2023-01-12 15:24:49 +00:00
if (args.offset)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.offset);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
GLSL: Ensure correct signed integer type for more texture functions.
2022-02-16 10:13:29 +00:00
farg_str += bitcast_expression(SPIRType::Int, args.offset);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.sample)
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
{
farg_str += ", ";
GLSL: Ensure correct signed integer type for more texture functions.
2022-02-16 10:13:29 +00:00
farg_str += bitcast_expression(SPIRType::Int, args.sample);
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.min_lod)
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
{
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.min_lod);
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.sparse_texel)
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
{
// Sparse texel output parameter comes after everything else, except it's before the optional, component/bias arguments.
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.sparse_texel);
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
}
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
if (args.bias)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.bias);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
farg_str += to_expression(args.bias);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
GLSL: Add error checking and extension fallback for textureGather
2020-11-06 23:01:57 +00:00
if (args.component && !expression_is_constant_null(args.component))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Refactor texture fetch function generation. Use structs instead of a million bool/uint32_t arguments passed on stack.
2020-06-05 13:49:17 +00:00
forward = forward && should_forward(args.component);
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
farg_str += ", ";
GLSL: Ensure correct signed integer type for more texture functions.
2022-02-16 10:13:29 +00:00
farg_str += bitcast_expression(SPIRType::Int, args.component);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
*p_forward = forward;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor emit_texture_op() function. CompilerGLSL add to_function_name() and to_function_args() functions to organize structure of emit_texture_op() function. CompilerMSL add support for MSL gather(), gather_compare() and sample_compare() functions.
2016-12-28 23:36:42 +00:00
return farg_str;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Add relax_nan_checks options. Makes codegen from typical D3D emulation SPIR-V more readable. Also makes cross compilation with NotEqual more sensible. It's very rare to actually need the strict NaN-checks in practice. Also, glslang now emits UnordNotEqual by default it seems, so give up trying to assume OrdNotEqual. Harmonize for UnordNotEqual as the sane default.
2022-03-03 10:04:45 +00:00
Op CompilerGLSL::get_remapped_spirv_op(Op op) const
{
if (options.relax_nan_checks)
{
switch (op)
{
case OpFUnordLessThan:
op = OpFOrdLessThan;
break;
case OpFUnordLessThanEqual:
op = OpFOrdLessThanEqual;
break;
case OpFUnordGreaterThan:
op = OpFOrdGreaterThan;
break;
case OpFUnordGreaterThanEqual:
op = OpFOrdGreaterThanEqual;
break;
case OpFUnordEqual:
op = OpFOrdEqual;
break;
case OpFOrdNotEqual:
op = OpFUnordNotEqual;
break;
default:
break;
}
}
return op;
}
GLSLstd450 CompilerGLSL::get_remapped_glsl_op(GLSLstd450 std450_op) const
{
// Relax to non-NaN aware opcodes.
if (options.relax_nan_checks)
{
switch (std450_op)
{
case GLSLstd450NClamp:
std450_op = GLSLstd450FClamp;
break;
case GLSLstd450NMin:
std450_op = GLSLstd450FMin;
break;
case GLSLstd450NMax:
std450_op = GLSLstd450FMax;
break;
default:
break;
}
}
return std450_op;
}
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
void CompilerGLSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t length)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Be a bit smarter about uint on legacy targets. Allow constants (array sizes for example), but using unsigned opcodes, and unsigned-specific opcodes is a problem.
2018-04-17 12:56:49 +00:00
auto op = static_cast<GLSLstd450>(eop);
if (is_legacy() && is_unsigned_glsl_opcode(op))
SPIRV_CROSS_THROW("Unsigned integers are not supported on legacy GLSL targets.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
// If we need to do implicit bitcasts, make sure we do it with the correct type.
uint32_t integer_width = get_integer_width_for_glsl_instruction(op, args, length);
auto int_type = to_signed_basetype(integer_width);
auto uint_type = to_unsigned_basetype(integer_width);
Add relax_nan_checks options. Makes codegen from typical D3D emulation SPIR-V more readable. Also makes cross compilation with NotEqual more sensible. It's very rare to actually need the strict NaN-checks in practice. Also, glslang now emits UnordNotEqual by default it seems, so give up trying to assume OrdNotEqual. Harmonize for UnordNotEqual as the sane default.
2022-03-03 10:04:45 +00:00
op = get_remapped_glsl_op(op);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (op)
{
// FP fiddling
case GLSLstd450Round:
GLSL: Fix round/roundEven for legacy GLSL.
2020-11-06 16:34:38 +00:00
if (!is_legacy())
emit_unary_func_op(result_type, id, args[0], "round");
else
{
auto op0 = to_enclosed_expression(args[0]);
auto &op0_type = expression_type(args[0]);
auto expr = join("floor(", op0, " + ", type_to_glsl_constructor(op0_type), "(0.5))");
bool forward = should_forward(args[0]);
emit_op(result_type, id, expr, forward);
inherit_expression_dependencies(id, args[0]);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
case GLSLstd450RoundEven:
GLSL: Fix round/roundEven for legacy GLSL.
2020-11-06 16:34:38 +00:00
if (!is_legacy())
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
emit_unary_func_op(result_type, id, args[0], "roundEven");
GLSL: Fix round/roundEven for legacy GLSL.
2020-11-06 16:34:38 +00:00
else if (!options.es)
{
// This extension provides round() with round-to-even semantics.
require_extension_internal("GL_EXT_gpu_shader4");
emit_unary_func_op(result_type, id, args[0], "round");
}
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
else
GLSL: Fix round/roundEven for legacy GLSL.
2020-11-06 16:34:38 +00:00
SPIRV_CROSS_THROW("roundEven supported only in ESSL 300.");
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450Trunc:
GLSL: Add support for modf, isnan and isinf in legacy GLSL
2023-01-19 10:57:37 +00:00
if (!is_legacy())
emit_unary_func_op(result_type, id, args[0], "trunc");
else
{
// Implement by value-casting to int and back.
bool forward = should_forward(args[0]);
auto op0 = to_unpacked_expression(args[0]);
auto &op0_type = expression_type(args[0]);
auto via_type = op0_type;
via_type.basetype = SPIRType::Int;
auto expr = join(type_to_glsl(op0_type), "(", type_to_glsl(via_type), "(", op0, "))");
emit_op(result_type, id, expr, forward);
inherit_expression_dependencies(id, args[0]);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
GLSL: Add support for modf, isnan and isinf in legacy GLSL
2023-01-19 10:57:37 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450SAbs:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_unary_func_op_cast(result_type, id, args[0], "abs", int_type, int_type);
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450FAbs:
emit_unary_func_op(result_type, id, args[0], "abs");
break;
case GLSLstd450SSign:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_unary_func_op_cast(result_type, id, args[0], "sign", int_type, int_type);
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450FSign:
emit_unary_func_op(result_type, id, args[0], "sign");
break;
case GLSLstd450Floor:
emit_unary_func_op(result_type, id, args[0], "floor");
break;
case GLSLstd450Ceil:
emit_unary_func_op(result_type, id, args[0], "ceil");
break;
case GLSLstd450Fract:
emit_unary_func_op(result_type, id, args[0], "fract");
break;
case GLSLstd450Radians:
emit_unary_func_op(result_type, id, args[0], "radians");
break;
case GLSLstd450Degrees:
emit_unary_func_op(result_type, id, args[0], "degrees");
break;
case GLSLstd450Fma:
Support fma() in older GLSL targets.
2019-04-08 08:33:34 +00:00
if ((!options.es && options.version < 400) || (options.es && options.version < 320))
{
auto expr = join(to_enclosed_expression(args[0]), " * ", to_enclosed_expression(args[1]), " + ",
to_enclosed_expression(args[2]));
emit_op(result_type, id, expr,
should_forward(args[0]) && should_forward(args[1]) && should_forward(args[2]));
for (uint32_t i = 0; i < 3; i++)
inherit_expression_dependencies(id, args[i]);
}
else
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "fma");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
GLSL: Add support for modf, isnan and isinf in legacy GLSL
2023-01-19 10:57:37 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450Modf:
register_call_out_argument(args[1]);
GLSL: Add support for modf, isnan and isinf in legacy GLSL
2023-01-19 10:57:37 +00:00
if (!is_legacy())
{
forced_temporaries.insert(id);
emit_binary_func_op(result_type, id, args[0], args[1], "modf");
}
else
{
//NB. legacy GLSL doesn't have trunc() either, so we do a value cast
auto &op1_type = expression_type(args[1]);
auto via_type = op1_type;
via_type.basetype = SPIRType::Int;
statement(to_expression(args[1]), " = ",
type_to_glsl(op1_type), "(", type_to_glsl(via_type),
"(", to_expression(args[0]), "));");
emit_binary_op(result_type, id, args[0], args[1], "-");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Support FrexpStruct/ModfStruct.
2017-09-04 08:24:21 +00:00
case GLSLstd450ModfStruct:
{
auto &type = get<SPIRType>(result_type);
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
emit_uninitialized_temporary_expression(result_type, id);
GLSL: Add support for modf, isnan and isinf in legacy GLSL
2023-01-19 10:57:37 +00:00
if (!is_legacy())
{
statement(to_expression(id), ".", to_member_name(type, 0), " = ", "modf(", to_expression(args[0]), ", ",
to_expression(id), ".", to_member_name(type, 1), ");");
}
else
{
//NB. legacy GLSL doesn't have trunc() either, so we do a value cast
auto &op0_type = expression_type(args[0]);
auto via_type = op0_type;
via_type.basetype = SPIRType::Int;
statement(to_expression(id), ".", to_member_name(type, 1), " = ", type_to_glsl(op0_type),
"(", type_to_glsl(via_type), "(", to_expression(args[0]), "));");
statement(to_expression(id), ".", to_member_name(type, 0), " = ", to_enclosed_expression(args[0]), " - ",
to_expression(id), ".", to_member_name(type, 1), ";");
}
Support FrexpStruct/ModfStruct.
2017-09-04 08:24:21 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Minmax
case GLSLstd450UMin:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_binary_func_op_cast(result_type, id, args[0], args[1], "min", uint_type, false);
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450SMin:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_binary_func_op_cast(result_type, id, args[0], args[1], "min", int_type, false);
break;
case GLSLstd450FMin:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_binary_func_op(result_type, id, args[0], args[1], "min");
break;
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450FMax:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_binary_func_op(result_type, id, args[0], args[1], "max");
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450UMax:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_binary_func_op_cast(result_type, id, args[0], args[1], "max", uint_type, false);
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450SMax:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_binary_func_op_cast(result_type, id, args[0], args[1], "max", int_type, false);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450FClamp:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "clamp");
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450UClamp:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_trinary_func_op_cast(result_type, id, args[0], args[1], args[2], "clamp", uint_type);
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450SClamp:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_trinary_func_op_cast(result_type, id, args[0], args[1], args[2], "clamp", int_type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
// Trig
case GLSLstd450Sin:
emit_unary_func_op(result_type, id, args[0], "sin");
break;
case GLSLstd450Cos:
emit_unary_func_op(result_type, id, args[0], "cos");
break;
case GLSLstd450Tan:
emit_unary_func_op(result_type, id, args[0], "tan");
break;
case GLSLstd450Asin:
emit_unary_func_op(result_type, id, args[0], "asin");
break;
case GLSLstd450Acos:
emit_unary_func_op(result_type, id, args[0], "acos");
break;
case GLSLstd450Atan:
emit_unary_func_op(result_type, id, args[0], "atan");
break;
case GLSLstd450Sinh:
GLSL/HLSL: Add emulated fallbacks for sinh/cosh/tanh/asinh/acosh/atanh The inverse hyperbolic functions are not supported in HLSL, and none of them are supported in legacy GLSL.
2023-01-19 16:00:20 +00:00
if (!is_legacy())
emit_unary_func_op(result_type, id, args[0], "sinh");
else
{
bool forward = should_forward(args[0]);
auto expr = join("(exp(", to_expression(args[0]), ") - exp(-", to_enclosed_expression(args[0]), ")) * 0.5");
emit_op(result_type, id, expr, forward);
inherit_expression_dependencies(id, args[0]);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case GLSLstd450Cosh:
GLSL/HLSL: Add emulated fallbacks for sinh/cosh/tanh/asinh/acosh/atanh The inverse hyperbolic functions are not supported in HLSL, and none of them are supported in legacy GLSL.
2023-01-19 16:00:20 +00:00
if (!is_legacy())
emit_unary_func_op(result_type, id, args[0], "cosh");
else
{
bool forward = should_forward(args[0]);
auto expr = join("(exp(", to_expression(args[0]), ") + exp(-", to_enclosed_expression(args[0]), ")) * 0.5");
emit_op(result_type, id, expr, forward);
inherit_expression_dependencies(id, args[0]);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case GLSLstd450Tanh:
GLSL/HLSL: Add emulated fallbacks for sinh/cosh/tanh/asinh/acosh/atanh The inverse hyperbolic functions are not supported in HLSL, and none of them are supported in legacy GLSL.
2023-01-19 16:00:20 +00:00
if (!is_legacy())
emit_unary_func_op(result_type, id, args[0], "tanh");
else
{
// Create temporaries to store the result of exp(arg) and exp(-arg).
uint32_t &ids = extra_sub_expressions[id];
if (!ids)
{
ids = ir.increase_bound_by(2);
// Inherit precision qualifier (legacy has no NoContraction).
if (has_decoration(id, DecorationRelaxedPrecision))
{
set_decoration(ids, DecorationRelaxedPrecision);
set_decoration(ids + 1, DecorationRelaxedPrecision);
}
}
uint32_t epos_id = ids;
uint32_t eneg_id = ids + 1;
emit_op(result_type, epos_id, join("exp(", to_expression(args[0]), ")"), false);
emit_op(result_type, eneg_id, join("exp(-", to_enclosed_expression(args[0]), ")"), false);
inherit_expression_dependencies(epos_id, args[0]);
inherit_expression_dependencies(eneg_id, args[0]);
auto expr = join("(", to_enclosed_expression(epos_id), " - ", to_enclosed_expression(eneg_id), ") / "
"(", to_enclosed_expression(epos_id), " + ", to_enclosed_expression(eneg_id), ")");
emit_op(result_type, id, expr, true);
inherit_expression_dependencies(id, epos_id);
inherit_expression_dependencies(id, eneg_id);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case GLSLstd450Asinh:
GLSL/HLSL: Add emulated fallbacks for sinh/cosh/tanh/asinh/acosh/atanh The inverse hyperbolic functions are not supported in HLSL, and none of them are supported in legacy GLSL.
2023-01-19 16:00:20 +00:00
if (!is_legacy())
emit_unary_func_op(result_type, id, args[0], "asinh");
else
emit_emulated_ahyper_op(result_type, id, args[0], GLSLstd450Asinh);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case GLSLstd450Acosh:
GLSL/HLSL: Add emulated fallbacks for sinh/cosh/tanh/asinh/acosh/atanh The inverse hyperbolic functions are not supported in HLSL, and none of them are supported in legacy GLSL.
2023-01-19 16:00:20 +00:00
if (!is_legacy())
emit_unary_func_op(result_type, id, args[0], "acosh");
else
emit_emulated_ahyper_op(result_type, id, args[0], GLSLstd450Acosh);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case GLSLstd450Atanh:
GLSL/HLSL: Add emulated fallbacks for sinh/cosh/tanh/asinh/acosh/atanh The inverse hyperbolic functions are not supported in HLSL, and none of them are supported in legacy GLSL.
2023-01-19 16:00:20 +00:00
if (!is_legacy())
emit_unary_func_op(result_type, id, args[0], "atanh");
else
emit_emulated_ahyper_op(result_type, id, args[0], GLSLstd450Atanh);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case GLSLstd450Atan2:
emit_binary_func_op(result_type, id, args[0], args[1], "atan");
break;
// Exponentials
case GLSLstd450Pow:
emit_binary_func_op(result_type, id, args[0], args[1], "pow");
break;
case GLSLstd450Exp:
emit_unary_func_op(result_type, id, args[0], "exp");
break;
case GLSLstd450Log:
emit_unary_func_op(result_type, id, args[0], "log");
break;
case GLSLstd450Exp2:
emit_unary_func_op(result_type, id, args[0], "exp2");
break;
case GLSLstd450Log2:
emit_unary_func_op(result_type, id, args[0], "log2");
break;
case GLSLstd450Sqrt:
emit_unary_func_op(result_type, id, args[0], "sqrt");
break;
case GLSLstd450InverseSqrt:
emit_unary_func_op(result_type, id, args[0], "inversesqrt");
break;
// Matrix math
case GLSLstd450Determinant:
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
{
// No need to transpose - it doesn't affect the determinant
auto *e = maybe_get<SPIRExpression>(args[0]);
bool old_transpose = e && e->need_transpose;
if (old_transpose)
e->need_transpose = false;
if (options.version < 150) // also matches ES 100
{
auto &type = expression_type(args[0]);
assert(type.vecsize >= 2 && type.vecsize <= 4);
assert(type.vecsize == type.columns);
// ARB_gpu_shader_fp64 needs GLSL 150, other types are not valid
if (type.basetype != SPIRType::Float)
SPIRV_CROSS_THROW("Unsupported type for matrix determinant");
bool relaxed = has_decoration(id, DecorationRelaxedPrecision);
require_polyfill(static_cast<Polyfill>(PolyfillDeterminant2x2 << (type.vecsize - 2)),
relaxed);
emit_unary_func_op(result_type, id, args[0],
(options.es && relaxed) ? "spvDeterminantMP" : "spvDeterminant");
}
else
emit_unary_func_op(result_type, id, args[0], "determinant");
if (old_transpose)
e->need_transpose = true;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450MatrixInverse:
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
{
// The inverse of the transpose is the same as the transpose of
// the inverse, so we can just flip need_transpose of the result.
auto *a = maybe_get<SPIRExpression>(args[0]);
bool old_transpose = a && a->need_transpose;
if (old_transpose)
a->need_transpose = false;
const char *func = "inverse";
if (options.version < 140) // also matches ES 100
{
auto &type = get<SPIRType>(result_type);
assert(type.vecsize >= 2 && type.vecsize <= 4);
assert(type.vecsize == type.columns);
// ARB_gpu_shader_fp64 needs GLSL 150, other types are invalid
if (type.basetype != SPIRType::Float)
SPIRV_CROSS_THROW("Unsupported type for matrix inverse");
bool relaxed = has_decoration(id, DecorationRelaxedPrecision);
require_polyfill(static_cast<Polyfill>(PolyfillMatrixInverse2x2 << (type.vecsize - 2)),
relaxed);
func = (options.es && relaxed) ? "spvInverseMP" : "spvInverse";
}
bool forward = should_forward(args[0]);
auto &e = emit_op(result_type, id, join(func, "(", to_unpacked_expression(args[0]), ")"), forward);
inherit_expression_dependencies(id, args[0]);
if (old_transpose)
{
e.need_transpose = true;
a->need_transpose = true;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Lerping
case GLSLstd450FMix:
case GLSLstd450IMix:
{
emit_mix_op(result_type, id, args[0], args[1], args[2]);
break;
}
case GLSLstd450Step:
emit_binary_func_op(result_type, id, args[0], args[1], "step");
break;
case GLSLstd450SmoothStep:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "smoothstep");
break;
// Packing
case GLSLstd450Frexp:
register_call_out_argument(args[1]);
forced_temporaries.insert(id);
emit_binary_func_op(result_type, id, args[0], args[1], "frexp");
break;
Support FrexpStruct/ModfStruct.
2017-09-04 08:24:21 +00:00
case GLSLstd450FrexpStruct:
{
auto &type = get<SPIRType>(result_type);
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
emit_uninitialized_temporary_expression(result_type, id);
Support FrexpStruct/ModfStruct.
2017-09-04 08:24:21 +00:00
statement(to_expression(id), ".", to_member_name(type, 0), " = ", "frexp(", to_expression(args[0]), ", ",
to_expression(id), ".", to_member_name(type, 1), ");");
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450Ldexp:
Deal with ldexp taking uint input. Need to value cast to int first.
2019-08-27 09:19:54 +00:00
{
bool forward = should_forward(args[0]) && should_forward(args[1]);
auto op0 = to_unpacked_expression(args[0]);
auto op1 = to_unpacked_expression(args[1]);
auto &op1_type = expression_type(args[1]);
if (op1_type.basetype != SPIRType::Int)
{
// Need a value cast here.
auto target_type = op1_type;
target_type.basetype = SPIRType::Int;
op1 = join(type_to_glsl_constructor(target_type), "(", op1, ")");
}
auto expr = join("ldexp(", op0, ", ", op1, ")");
emit_op(result_type, id, expr, forward);
inherit_expression_dependencies(id, args[0]);
inherit_expression_dependencies(id, args[1]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Deal with ldexp taking uint input. Need to value cast to int first.
2019-08-27 09:19:54 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450PackSnorm4x8:
emit_unary_func_op(result_type, id, args[0], "packSnorm4x8");
break;
case GLSLstd450PackUnorm4x8:
emit_unary_func_op(result_type, id, args[0], "packUnorm4x8");
break;
case GLSLstd450PackSnorm2x16:
emit_unary_func_op(result_type, id, args[0], "packSnorm2x16");
break;
case GLSLstd450PackUnorm2x16:
emit_unary_func_op(result_type, id, args[0], "packUnorm2x16");
break;
case GLSLstd450PackHalf2x16:
emit_unary_func_op(result_type, id, args[0], "packHalf2x16");
break;
case GLSLstd450UnpackSnorm4x8:
emit_unary_func_op(result_type, id, args[0], "unpackSnorm4x8");
break;
case GLSLstd450UnpackUnorm4x8:
emit_unary_func_op(result_type, id, args[0], "unpackUnorm4x8");
break;
case GLSLstd450UnpackSnorm2x16:
emit_unary_func_op(result_type, id, args[0], "unpackSnorm2x16");
break;
case GLSLstd450UnpackUnorm2x16:
emit_unary_func_op(result_type, id, args[0], "unpackUnorm2x16");
break;
case GLSLstd450UnpackHalf2x16:
emit_unary_func_op(result_type, id, args[0], "unpackHalf2x16");
break;
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
case GLSLstd450PackDouble2x32:
emit_unary_func_op(result_type, id, args[0], "packDouble2x32");
break;
case GLSLstd450UnpackDouble2x32:
emit_unary_func_op(result_type, id, args[0], "unpackDouble2x32");
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Vector math
case GLSLstd450Length:
emit_unary_func_op(result_type, id, args[0], "length");
break;
case GLSLstd450Distance:
emit_binary_func_op(result_type, id, args[0], args[1], "distance");
break;
case GLSLstd450Cross:
emit_binary_func_op(result_type, id, args[0], args[1], "cross");
break;
case GLSLstd450Normalize:
emit_unary_func_op(result_type, id, args[0], "normalize");
break;
case GLSLstd450FaceForward:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "faceforward");
break;
case GLSLstd450Reflect:
emit_binary_func_op(result_type, id, args[0], args[1], "reflect");
break;
case GLSLstd450Refract:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "refract");
break;
// Bit-fiddling
case GLSLstd450FindILsb:
Deal correctly with return sign of bitscan operations.
2019-07-12 08:57:56 +00:00
// findLSB always returns int.
emit_unary_func_op_cast(result_type, id, args[0], "findLSB", expression_type(args[0]).basetype, int_type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450FindSMsb:
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
emit_unary_func_op_cast(result_type, id, args[0], "findMSB", int_type, int_type);
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case GLSLstd450FindUMsb:
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
emit_unary_func_op_cast(result_type, id, args[0], "findMSB", uint_type,
int_type); // findMSB always returns int.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
// Multisampled varying
case GLSLstd450InterpolateAtCentroid:
emit_unary_func_op(result_type, id, args[0], "interpolateAtCentroid");
break;
case GLSLstd450InterpolateAtSample:
emit_binary_func_op(result_type, id, args[0], args[1], "interpolateAtSample");
break;
case GLSLstd450InterpolateAtOffset:
emit_binary_func_op(result_type, id, args[0], args[1], "interpolateAtOffset");
break;
Fail more gracefully with some unsupported opcodes.
2018-07-02 11:22:21 +00:00
case GLSLstd450NMin:
case GLSLstd450NMax:
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
{
GLSL: Use SPIR-V intrinsics for N{Min,Max,Clamp}. When targeting Vulkan semantics, we should emit code that is actually readable. Also, make sure to use plain F{Min,Max,Clamp} on HLSL. HLSL has NaN-aware semantics by default.
2024-05-21 14:52:51 +00:00
if (options.vulkan_semantics)
{
require_extension_internal("GL_EXT_spirv_intrinsics");
bool relaxed = has_decoration(id, DecorationRelaxedPrecision);
Polyfill poly = {};
switch (get<SPIRType>(result_type).width)
{
case 16:
poly = op == GLSLstd450NMin ? PolyfillNMin16 : PolyfillNMax16;
break;
case 32:
poly = op == GLSLstd450NMin ? PolyfillNMin32 : PolyfillNMax32;
break;
case 64:
poly = op == GLSLstd450NMin ? PolyfillNMin64 : PolyfillNMax64;
break;
default:
SPIRV_CROSS_THROW("Invalid bit width for NMin/NMax.");
}
require_polyfill(poly, relaxed);
// Function return decorations are broken, so need to do double polyfill.
if (relaxed)
require_polyfill(poly, false);
const char *op_str;
if (relaxed)
op_str = op == GLSLstd450NMin ? "spvNMinRelaxed" : "spvNMaxRelaxed";
else
op_str = op == GLSLstd450NMin ? "spvNMin" : "spvNMax";
emit_binary_func_op(result_type, id, args[0], args[1], op_str);
}
else
{
emit_nminmax_op(result_type, id, args[0], args[1], op);
}
Fail more gracefully with some unsupported opcodes.
2018-07-02 11:22:21 +00:00
break;
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
}
Fail more gracefully with some unsupported opcodes.
2018-07-02 11:22:21 +00:00
case GLSLstd450NClamp:
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
{
GLSL: Use SPIR-V intrinsics for N{Min,Max,Clamp}. When targeting Vulkan semantics, we should emit code that is actually readable. Also, make sure to use plain F{Min,Max,Clamp} on HLSL. HLSL has NaN-aware semantics by default.
2024-05-21 14:52:51 +00:00
if (options.vulkan_semantics)
{
require_extension_internal("GL_EXT_spirv_intrinsics");
bool relaxed = has_decoration(id, DecorationRelaxedPrecision);
Polyfill poly = {};
switch (get<SPIRType>(result_type).width)
{
case 16:
poly = PolyfillNClamp16;
break;
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
GLSL: Use SPIR-V intrinsics for N{Min,Max,Clamp}. When targeting Vulkan semantics, we should emit code that is actually readable. Also, make sure to use plain F{Min,Max,Clamp} on HLSL. HLSL has NaN-aware semantics by default.
2024-05-21 14:52:51 +00:00
case 32:
poly = PolyfillNClamp32;
break;
case 64:
poly = PolyfillNClamp64;
break;
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
GLSL: Use SPIR-V intrinsics for N{Min,Max,Clamp}. When targeting Vulkan semantics, we should emit code that is actually readable. Also, make sure to use plain F{Min,Max,Clamp} on HLSL. HLSL has NaN-aware semantics by default.
2024-05-21 14:52:51 +00:00
default:
SPIRV_CROSS_THROW("Invalid bit width for NMin/NMax.");
}
require_polyfill(poly, relaxed);
// Function return decorations are broken, so need to do double polyfill.
if (relaxed)
require_polyfill(poly, false);
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], relaxed ? "spvNClampRelaxed" : "spvNClamp");
}
else
{
// Make sure we have a unique ID here to avoid aliasing the extra sub-expressions between clamp and NMin sub-op.
// IDs cannot exceed 24 bits, so we can make use of the higher bits for some unique flags.
uint32_t &max_id = extra_sub_expressions[id | EXTRA_SUB_EXPRESSION_TYPE_AUX];
if (!max_id)
max_id = ir.increase_bound_by(1);
// Inherit precision qualifiers.
ir.meta[max_id] = ir.meta[id];
emit_nminmax_op(result_type, max_id, args[0], args[1], GLSLstd450NMax);
emit_nminmax_op(result_type, id, max_id, args[2], GLSLstd450NMin);
}
Fail more gracefully with some unsupported opcodes.
2018-07-02 11:22:21 +00:00
break;
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
}
Fail more gracefully with some unsupported opcodes.
2018-07-02 11:22:21 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
statement("// unimplemented GLSL op ", eop);
break;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
void CompilerGLSL::emit_nminmax_op(uint32_t result_type, uint32_t id, uint32_t op0, uint32_t op1, GLSLstd450 op)
{
// Need to emulate this call.
uint32_t &ids = extra_sub_expressions[id];
if (!ids)
{
ids = ir.increase_bound_by(5);
auto btype = get<SPIRType>(result_type);
btype.basetype = SPIRType::Boolean;
set<SPIRType>(ids, btype);
}
uint32_t btype_id = ids + 0;
uint32_t left_nan_id = ids + 1;
uint32_t right_nan_id = ids + 2;
uint32_t tmp_id = ids + 3;
uint32_t mixed_first_id = ids + 4;
// Inherit precision qualifiers.
ir.meta[tmp_id] = ir.meta[id];
ir.meta[mixed_first_id] = ir.meta[id];
GLSL: Add support for modf, isnan and isinf in legacy GLSL
2023-01-19 10:57:37 +00:00
if (!is_legacy())
{
emit_unary_func_op(btype_id, left_nan_id, op0, "isnan");
emit_unary_func_op(btype_id, right_nan_id, op1, "isnan");
}
else if (expression_type(op0).vecsize > 1)
{
// If the number doesn't equal itself, it must be NaN
emit_binary_func_op(btype_id, left_nan_id, op0, op0, "notEqual");
emit_binary_func_op(btype_id, right_nan_id, op1, op1, "notEqual");
}
else
{
emit_binary_op(btype_id, left_nan_id, op0, op0, "!=");
emit_binary_op(btype_id, right_nan_id, op1, op1, "!=");
}
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
emit_binary_func_op(result_type, tmp_id, op0, op1, op == GLSLstd450NMin ? "min" : "max");
emit_mix_op(result_type, mixed_first_id, tmp_id, op1, left_nan_id);
emit_mix_op(result_type, id, mixed_first_id, op0, right_nan_id);
}
GLSL/HLSL: Add emulated fallbacks for sinh/cosh/tanh/asinh/acosh/atanh The inverse hyperbolic functions are not supported in HLSL, and none of them are supported in legacy GLSL.
2023-01-19 16:00:20 +00:00
void CompilerGLSL::emit_emulated_ahyper_op(uint32_t result_type, uint32_t id, uint32_t op0, GLSLstd450 op)
{
const char *one = backend.float_literal_suffix ? "1.0f" : "1.0";
std::string expr;
bool forward = should_forward(op0);
switch (op)
{
case GLSLstd450Asinh:
expr = join("log(", to_enclosed_expression(op0), " + sqrt(",
to_enclosed_expression(op0), " * ", to_enclosed_expression(op0), " + ", one, "))");
emit_op(result_type, id, expr, forward);
break;
case GLSLstd450Acosh:
expr = join("log(", to_enclosed_expression(op0), " + sqrt(",
to_enclosed_expression(op0), " * ", to_enclosed_expression(op0), " - ", one, "))");
break;
case GLSLstd450Atanh:
expr = join("log((", one, " + ", to_enclosed_expression(op0), ") / "
"(", one, " - ", to_enclosed_expression(op0), ")) * 0.5",
backend.float_literal_suffix ? "f" : "");
break;
default:
SPIRV_CROSS_THROW("Invalid op.");
}
emit_op(result_type, id, expr, forward);
inherit_expression_dependencies(id, op0);
}
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
void CompilerGLSL::emit_spv_amd_shader_ballot_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args,
uint32_t)
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_AMD_shader_ballot");
Add support for new extensions.
2017-11-21 13:04:57 +00:00
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
enum AMDShaderBallot
{
Add support for new extensions.
2017-11-21 13:04:57 +00:00
SwizzleInvocationsAMD = 1,
SwizzleInvocationsMaskedAMD = 2,
WriteInvocationAMD = 3,
MbcntAMD = 4
};
auto op = static_cast<AMDShaderBallot>(eop);
switch (op)
{
case SwizzleInvocationsAMD:
emit_binary_func_op(result_type, id, args[0], args[1], "swizzleInvocationsAMD");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(id);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
case SwizzleInvocationsMaskedAMD:
emit_binary_func_op(result_type, id, args[0], args[1], "swizzleInvocationsMaskedAMD");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(id);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
case WriteInvocationAMD:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "writeInvocationAMD");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(id);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
case MbcntAMD:
emit_unary_func_op(result_type, id, args[0], "mbcntAMD");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(id);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
default:
statement("// unimplemented SPV AMD shader ballot op ", eop);
break;
}
}
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
void CompilerGLSL::emit_spv_amd_shader_explicit_vertex_parameter_op(uint32_t result_type, uint32_t id, uint32_t eop,
const uint32_t *args, uint32_t)
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_AMD_shader_explicit_vertex_parameter");
Add support for new extensions.
2017-11-21 13:04:57 +00:00
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
enum AMDShaderExplicitVertexParameter
{
Add support for new extensions.
2017-11-21 13:04:57 +00:00
InterpolateAtVertexAMD = 1
};
auto op = static_cast<AMDShaderExplicitVertexParameter>(eop);
switch (op)
{
case InterpolateAtVertexAMD:
emit_binary_func_op(result_type, id, args[0], args[1], "interpolateAtVertexAMD");
break;
default:
statement("// unimplemented SPV AMD shader explicit vertex parameter op ", eop);
break;
}
}
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
void CompilerGLSL::emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t id, uint32_t eop,
const uint32_t *args, uint32_t)
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_AMD_shader_trinary_minmax");
Add support for new extensions.
2017-11-21 13:04:57 +00:00
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
enum AMDShaderTrinaryMinMax
{
Add support for new extensions.
2017-11-21 13:04:57 +00:00
FMin3AMD = 1,
UMin3AMD = 2,
SMin3AMD = 3,
FMax3AMD = 4,
UMax3AMD = 5,
SMax3AMD = 6,
FMid3AMD = 7,
UMid3AMD = 8,
SMid3AMD = 9
};
auto op = static_cast<AMDShaderTrinaryMinMax>(eop);
switch (op)
{
case FMin3AMD:
case UMin3AMD:
case SMin3AMD:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "min3");
break;
case FMax3AMD:
case UMax3AMD:
case SMax3AMD:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "max3");
break;
case FMid3AMD:
case UMid3AMD:
case SMid3AMD:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "mid3");
break;
default:
statement("// unimplemented SPV AMD shader trinary minmax op ", eop);
break;
}
}
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
void CompilerGLSL::emit_spv_amd_gcn_shader_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args,
uint32_t)
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_AMD_gcn_shader");
Add support for new extensions.
2017-11-21 13:04:57 +00:00
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
enum AMDGCNShader
{
Add support for new extensions.
2017-11-21 13:04:57 +00:00
CubeFaceIndexAMD = 1,
CubeFaceCoordAMD = 2,
TimeAMD = 3
};
auto op = static_cast<AMDGCNShader>(eop);
switch (op)
{
case CubeFaceIndexAMD:
emit_unary_func_op(result_type, id, args[0], "cubeFaceIndexAMD");
break;
case CubeFaceCoordAMD:
emit_unary_func_op(result_type, id, args[0], "cubeFaceCoordAMD");
break;
case TimeAMD:
{
string expr = "timeAMD()";
emit_op(result_type, id, expr, true);
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(id);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
default:
statement("// unimplemented SPV AMD gcn shader op ", eop);
break;
}
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
void CompilerGLSL::emit_subgroup_op(const Instruction &i)
{
const uint32_t *ops = stream(i);
auto op = static_cast<Op>(i.op);
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
if (!options.vulkan_semantics && !is_supported_subgroup_op_in_opengl(op, ops))
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("This subgroup operation is only supported in Vulkan semantics.");
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
GLSL: Deal with sign in subgroup Min/Max operations.
2020-01-09 11:01:54 +00:00
// If we need to do implicit bitcasts, make sure we do it with the correct type.
uint32_t integer_width = get_integer_width_for_instruction(i);
auto int_type = to_signed_basetype(integer_width);
auto uint_type = to_unsigned_basetype(integer_width);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
switch (op)
{
case OpGroupNonUniformElect:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupElect);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
break;
case OpGroupNonUniformBallotBitCount:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
const GroupOperation operation = static_cast<GroupOperation>(ops[3]);
if (operation == GroupOperationReduce)
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBallotBitCount);
else if (operation == GroupOperationInclusiveScan || operation == GroupOperationExclusiveScan)
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupInverseBallot_InclBitCount_ExclBitCout);
}
break;
case OpGroupNonUniformBallotBitExtract:
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBallotBitExtract);
break;
case OpGroupNonUniformInverseBallot:
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupInverseBallot_InclBitCount_ExclBitCout);
break;
case OpGroupNonUniformBallot:
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBallot);
break;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformBallotFindLSB:
case OpGroupNonUniformBallotFindMSB:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBallotFindLSB_MSB);
break;
case OpGroupNonUniformBroadcast:
case OpGroupNonUniformBroadcastFirst:
GLSL: Fix KHR subgroup extension table for subgroups.
2020-12-11 11:24:34 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBroadcast_First);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
break;
case OpGroupNonUniformShuffle:
case OpGroupNonUniformShuffleXor:
require_extension_internal("GL_KHR_shader_subgroup_shuffle");
break;
case OpGroupNonUniformShuffleUp:
case OpGroupNonUniformShuffleDown:
require_extension_internal("GL_KHR_shader_subgroup_shuffle_relative");
break;
case OpGroupNonUniformAll:
case OpGroupNonUniformAny:
case OpGroupNonUniformAllEqual:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
const SPIRType &type = expression_type(ops[3]);
if (type.basetype == SPIRType::BaseType::Boolean && type.vecsize == 1u)
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupAll_Any_AllEqualBool);
else
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupAllEqualT);
}
break;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
// clang-format off
#define GLSL_GROUP_OP(OP)\
case OpGroupNonUniform##OP:\
{\
auto operation = static_cast<GroupOperation>(ops[3]);\
if (operation == GroupOperationClusteredReduce)\
require_extension_internal("GL_KHR_shader_subgroup_clustered");\
else if (operation == GroupOperationReduce)\
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupArithmetic##OP##Reduce);\
else if (operation == GroupOperationExclusiveScan)\
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupArithmetic##OP##ExclusiveScan);\
else if (operation == GroupOperationInclusiveScan)\
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupArithmetic##OP##InclusiveScan);\
else\
SPIRV_CROSS_THROW("Invalid group operation.");\
break;\
}
GLSL_GROUP_OP(IAdd)
GLSL_GROUP_OP(FAdd)
GLSL_GROUP_OP(IMul)
GLSL_GROUP_OP(FMul)
GLSL: Support KHR_subgroup_arithmetic FAdd Support NV workarounds for FAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-02 07:45:25 +00:00
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
#undef GLSL_GROUP_OP
// clang-format on
GLSL: Support KHR_subgroup_arithmetic FAdd Support NV workarounds for FAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-02 07:45:25 +00:00
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformFMin:
case OpGroupNonUniformFMax:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
case OpGroupNonUniformSMin:
case OpGroupNonUniformSMax:
case OpGroupNonUniformUMin:
case OpGroupNonUniformUMax:
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformBitwiseAnd:
case OpGroupNonUniformBitwiseOr:
case OpGroupNonUniformBitwiseXor:
GLSL: Add support for Logical subgroup ops. Completely missed these ...
2021-03-08 11:06:46 +00:00
case OpGroupNonUniformLogicalAnd:
case OpGroupNonUniformLogicalOr:
case OpGroupNonUniformLogicalXor:
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
{
auto operation = static_cast<GroupOperation>(ops[3]);
if (operation == GroupOperationClusteredReduce)
{
require_extension_internal("GL_KHR_shader_subgroup_clustered");
}
Run format_all.sh.
2018-04-17 13:01:31 +00:00
else if (operation == GroupOperationExclusiveScan || operation == GroupOperationInclusiveScan ||
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
operation == GroupOperationReduce)
{
require_extension_internal("GL_KHR_shader_subgroup_arithmetic");
}
else
SPIRV_CROSS_THROW("Invalid group operation.");
break;
}
case OpGroupNonUniformQuadSwap:
case OpGroupNonUniformQuadBroadcast:
require_extension_internal("GL_KHR_shader_subgroup_quad");
break;
default:
SPIRV_CROSS_THROW("Invalid opcode for subgroup.");
}
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
auto scope = static_cast<Scope>(evaluate_constant_u32(ops[2]));
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
if (scope != ScopeSubgroup)
SPIRV_CROSS_THROW("Only subgroup scope is supported.");
switch (op)
{
case OpGroupNonUniformElect:
emit_op(result_type, id, "subgroupElect()", true);
break;
case OpGroupNonUniformBroadcast:
emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupBroadcast");
break;
case OpGroupNonUniformBroadcastFirst:
emit_unary_func_op(result_type, id, ops[3], "subgroupBroadcastFirst");
break;
case OpGroupNonUniformBallot:
emit_unary_func_op(result_type, id, ops[3], "subgroupBallot");
break;
case OpGroupNonUniformInverseBallot:
emit_unary_func_op(result_type, id, ops[3], "subgroupInverseBallot");
break;
case OpGroupNonUniformBallotBitExtract:
emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupBallotBitExtract");
break;
case OpGroupNonUniformBallotFindLSB:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
emit_unary_func_op(result_type, id, ops[3], "subgroupBallotFindLSB");
break;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformBallotFindMSB:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
emit_unary_func_op(result_type, id, ops[3], "subgroupBallotFindMSB");
break;
case OpGroupNonUniformBallotBitCount:
{
auto operation = static_cast<GroupOperation>(ops[3]);
if (operation == GroupOperationReduce)
emit_unary_func_op(result_type, id, ops[4], "subgroupBallotBitCount");
else if (operation == GroupOperationInclusiveScan)
emit_unary_func_op(result_type, id, ops[4], "subgroupBallotInclusiveBitCount");
else if (operation == GroupOperationExclusiveScan)
emit_unary_func_op(result_type, id, ops[4], "subgroupBallotExclusiveBitCount");
else
SPIRV_CROSS_THROW("Invalid BitCount operation.");
break;
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformShuffle:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupShuffle");
break;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformShuffleXor:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupShuffleXor");
break;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformShuffleUp:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupShuffleUp");
break;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformShuffleDown:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupShuffleDown");
break;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformAll:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
emit_unary_func_op(result_type, id, ops[3], "subgroupAll");
break;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformAny:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
emit_unary_func_op(result_type, id, ops[3], "subgroupAny");
break;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformAllEqual:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
emit_unary_func_op(result_type, id, ops[3], "subgroupAllEqual");
break;
Run format_all.sh.
2018-04-17 13:01:31 +00:00
// clang-format off
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define GLSL_GROUP_OP(op, glsl_op) \
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
case OpGroupNonUniform##op: \
{ \
auto operation = static_cast<GroupOperation>(ops[3]); \
if (operation == GroupOperationReduce) \
emit_unary_func_op(result_type, id, ops[4], "subgroup" #glsl_op); \
else if (operation == GroupOperationInclusiveScan) \
emit_unary_func_op(result_type, id, ops[4], "subgroupInclusive" #glsl_op); \
else if (operation == GroupOperationExclusiveScan) \
emit_unary_func_op(result_type, id, ops[4], "subgroupExclusive" #glsl_op); \
else if (operation == GroupOperationClusteredReduce) \
emit_binary_func_op(result_type, id, ops[4], ops[5], "subgroupClustered" #glsl_op); \
else \
SPIRV_CROSS_THROW("Invalid group operation."); \
break; \
}
GLSL: Deal with sign in subgroup Min/Max operations.
2020-01-09 11:01:54 +00:00
#define GLSL_GROUP_OP_CAST(op, glsl_op, type) \
case OpGroupNonUniform##op: \
{ \
auto operation = static_cast<GroupOperation>(ops[3]); \
if (operation == GroupOperationReduce) \
emit_unary_func_op_cast(result_type, id, ops[4], "subgroup" #glsl_op, type, type); \
else if (operation == GroupOperationInclusiveScan) \
emit_unary_func_op_cast(result_type, id, ops[4], "subgroupInclusive" #glsl_op, type, type); \
else if (operation == GroupOperationExclusiveScan) \
emit_unary_func_op_cast(result_type, id, ops[4], "subgroupExclusive" #glsl_op, type, type); \
else if (operation == GroupOperationClusteredReduce) \
emit_binary_func_op_cast_clustered(result_type, id, ops[4], ops[5], "subgroupClustered" #glsl_op, type); \
else \
SPIRV_CROSS_THROW("Invalid group operation."); \
break; \
}
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_GROUP_OP(FAdd, Add)
GLSL_GROUP_OP(FMul, Mul)
GLSL_GROUP_OP(FMin, Min)
GLSL_GROUP_OP(FMax, Max)
GLSL_GROUP_OP(IAdd, Add)
GLSL_GROUP_OP(IMul, Mul)
GLSL: Deal with sign in subgroup Min/Max operations.
2020-01-09 11:01:54 +00:00
GLSL_GROUP_OP_CAST(SMin, Min, int_type)
GLSL_GROUP_OP_CAST(SMax, Max, int_type)
GLSL_GROUP_OP_CAST(UMin, Min, uint_type)
GLSL_GROUP_OP_CAST(UMax, Max, uint_type)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_GROUP_OP(BitwiseAnd, And)
GLSL_GROUP_OP(BitwiseOr, Or)
GLSL_GROUP_OP(BitwiseXor, Xor)
GLSL: Add support for Logical subgroup ops. Completely missed these ...
2021-03-08 11:06:46 +00:00
GLSL_GROUP_OP(LogicalAnd, And)
GLSL_GROUP_OP(LogicalOr, Or)
GLSL_GROUP_OP(LogicalXor, Xor)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#undef GLSL_GROUP_OP
GLSL: Deal with sign in subgroup Min/Max operations.
2020-01-09 11:01:54 +00:00
#undef GLSL_GROUP_OP_CAST
Run format_all.sh.
2018-04-17 13:01:31 +00:00
// clang-format on
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformQuadSwap:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
{
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
uint32_t direction = evaluate_constant_u32(ops[4]);
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
if (direction == 0)
emit_unary_func_op(result_type, id, ops[3], "subgroupQuadSwapHorizontal");
else if (direction == 1)
emit_unary_func_op(result_type, id, ops[3], "subgroupQuadSwapVertical");
else if (direction == 2)
emit_unary_func_op(result_type, id, ops[3], "subgroupQuadSwapDiagonal");
else
SPIRV_CROSS_THROW("Invalid quad swap direction.");
break;
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformQuadBroadcast:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
{
emit_binary_func_op(result_type, id, ops[3], ops[4], "subgroupQuadBroadcast");
break;
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
default:
SPIRV_CROSS_THROW("Invalid opcode for subgroup.");
}
register_control_dependent_expression(id);
}
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
string CompilerGLSL::bitcast_glsl_op(const SPIRType &out_type, const SPIRType &in_type)
Initial commit.
2016-03-02 17:09:16 +00:00
{
GLSL: Support OpBitcast for buffer references. Update glslang/SPIRV-Tools/SPIRV-Headers references.
2019-05-09 08:27:28 +00:00
// OpBitcast can deal with pointers.
if (out_type.pointer || in_type.pointer)
GLSL: Emit GL_EXT_buffer_reference_uvec2 as required.
2021-09-02 11:11:36 +00:00
{
if (out_type.vecsize == 2 || in_type.vecsize == 2)
require_extension_internal("GL_EXT_buffer_reference_uvec2");
GLSL: Support OpBitcast for buffer references. Update glslang/SPIRV-Tools/SPIRV-Headers references.
2019-05-09 08:27:28 +00:00
return type_to_glsl(out_type);
GLSL: Emit GL_EXT_buffer_reference_uvec2 as required.
2021-09-02 11:11:36 +00:00
}
GLSL: Support OpBitcast for buffer references. Update glslang/SPIRV-Tools/SPIRV-Headers references.
2019-05-09 08:27:28 +00:00
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
if (out_type.basetype == in_type.basetype)
return "";
Move assertions after the check for equal types. `bitcast_glsl_op()` is sometimes called for `Boolean` types, e.g. for specialization constants. We don't want the assert to trip if this is going to be a no-op anyway.
2019-01-31 02:19:05 +00:00
assert(out_type.basetype != SPIRType::Boolean);
assert(in_type.basetype != SPIRType::Boolean);
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
bool integral_cast = type_is_integral(out_type) && type_is_integral(in_type);
bool same_size_cast = out_type.width == in_type.width;
// Trivial bitcast case, casts between integers.
if (integral_cast && same_size_cast)
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
return type_to_glsl(out_type);
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
// Catch-all 8-bit arithmetic casts (GL_EXT_shader_explicit_arithmetic_types).
if (out_type.width == 8 && in_type.width >= 16 && integral_cast && in_type.vecsize == 1)
return "unpack8";
else if (in_type.width == 8 && out_type.width == 16 && integral_cast && out_type.vecsize == 1)
return "pack16";
else if (in_type.width == 8 && out_type.width == 32 && integral_cast && out_type.vecsize == 1)
return "pack32";
// Floating <-> Integer special casts. Just have to enumerate all cases. :(
// 16-bit, 32-bit and 64-bit floats.
if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Float)
GLSL: Need extension to use bitcast on GLSL < 330.
2019-07-11 13:32:57 +00:00
{
if (is_legacy_es())
SPIRV_CROSS_THROW("Float -> Uint bitcast not supported on legacy ESSL.");
else if (!options.es && options.version < 330)
require_extension_internal("GL_ARB_shader_bit_encoding");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "floatBitsToUint";
GLSL: Need extension to use bitcast on GLSL < 330.
2019-07-11 13:32:57 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::Float)
GLSL: Need extension to use bitcast on GLSL < 330.
2019-07-11 13:32:57 +00:00
{
if (is_legacy_es())
SPIRV_CROSS_THROW("Float -> Int bitcast not supported on legacy ESSL.");
else if (!options.es && options.version < 330)
require_extension_internal("GL_ARB_shader_bit_encoding");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "floatBitsToInt";
GLSL: Need extension to use bitcast on GLSL < 330.
2019-07-11 13:32:57 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::UInt)
GLSL: Need extension to use bitcast on GLSL < 330.
2019-07-11 13:32:57 +00:00
{
if (is_legacy_es())
SPIRV_CROSS_THROW("Uint -> Float bitcast not supported on legacy ESSL.");
else if (!options.es && options.version < 330)
require_extension_internal("GL_ARB_shader_bit_encoding");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "uintBitsToFloat";
GLSL: Need extension to use bitcast on GLSL < 330.
2019-07-11 13:32:57 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::Int)
GLSL: Need extension to use bitcast on GLSL < 330.
2019-07-11 13:32:57 +00:00
{
if (is_legacy_es())
SPIRV_CROSS_THROW("Int -> Float bitcast not supported on legacy ESSL.");
else if (!options.es && options.version < 330)
require_extension_internal("GL_ARB_shader_bit_encoding");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "intBitsToFloat";
GLSL: Need extension to use bitcast on GLSL < 330.
2019-07-11 13:32:57 +00:00
}
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::Double)
return "doubleBitsToInt64";
else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Double)
return "doubleBitsToUint64";
else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::Int64)
return "int64BitsToDouble";
else if (out_type.basetype == SPIRType::Double && in_type.basetype == SPIRType::UInt64)
return "uint64BitsToDouble";
Support bitcasts of 16-bit types.
2018-11-05 20:55:56 +00:00
else if (out_type.basetype == SPIRType::Short && in_type.basetype == SPIRType::Half)
return "float16BitsToInt16";
else if (out_type.basetype == SPIRType::UShort && in_type.basetype == SPIRType::Half)
return "float16BitsToUint16";
else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::Short)
return "int16BitsToFloat16";
else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UShort)
return "uint16BitsToFloat16";
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
// And finally, some even more special purpose casts.
if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::UInt && in_type.vecsize == 2)
Add support for new extensions.
2017-11-21 13:04:57 +00:00
return "packUint2x32";
GLSL/HLSL: Support packUint2x32 and unpackUint2x32
2020-04-17 14:46:06 +00:00
else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::UInt64 && out_type.vecsize == 2)
return "unpackUint2x32";
Add test shader for FP16 support.
2018-03-06 15:28:42 +00:00
else if (out_type.basetype == SPIRType::Half && in_type.basetype == SPIRType::UInt && in_type.vecsize == 1)
return "unpackFloat2x16";
else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Half && in_type.vecsize == 2)
return "packFloat2x16";
Support bitcasts of 16-bit types.
2018-11-05 20:55:56 +00:00
else if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::Short && in_type.vecsize == 2)
return "packInt2x16";
else if (out_type.basetype == SPIRType::Short && in_type.basetype == SPIRType::Int && in_type.vecsize == 1)
return "unpackInt2x16";
else if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::UShort && in_type.vecsize == 2)
return "packUint2x16";
else if (out_type.basetype == SPIRType::UShort && in_type.basetype == SPIRType::UInt && in_type.vecsize == 1)
return "unpackUint2x16";
else if (out_type.basetype == SPIRType::Int64 && in_type.basetype == SPIRType::Short && in_type.vecsize == 4)
return "packInt4x16";
else if (out_type.basetype == SPIRType::Short && in_type.basetype == SPIRType::Int64 && in_type.vecsize == 1)
return "unpackInt4x16";
else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::UShort && in_type.vecsize == 4)
return "packUint4x16";
else if (out_type.basetype == SPIRType::UShort && in_type.basetype == SPIRType::UInt64 && in_type.vecsize == 1)
return "unpackUint4x16";
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
return "";
Initial commit.
2016-03-02 17:09:16 +00:00
}
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
string CompilerGLSL::bitcast_glsl(const SPIRType &result_type, uint32_t argument)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
auto op = bitcast_glsl_op(result_type, expression_type(argument));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (op.empty())
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
return to_enclosed_unpacked_expression(argument);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
return join(op, "(", to_unpacked_expression(argument), ")");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
std::string CompilerGLSL::bitcast_expression(SPIRType::BaseType target_type, uint32_t arg)
{
auto expr = to_expression(arg);
auto &src_type = expression_type(arg);
if (src_type.basetype != target_type)
{
auto target = src_type;
target.basetype = target_type;
expr = join(bitcast_glsl_op(target, src_type), "(", expr, ")");
}
return expr;
}
std::string CompilerGLSL::bitcast_expression(const SPIRType &target_type, SPIRType::BaseType expr_type,
const std::string &expr)
{
if (target_type.basetype == expr_type)
return expr;
auto src_type = target_type;
src_type.basetype = expr_type;
return join(bitcast_glsl_op(target_type, src_type), "(", expr, ")");
}
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
string CompilerGLSL::builtin_to_glsl(BuiltIn builtin, StorageClass storage)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (builtin)
{
case BuiltInPosition:
return "gl_Position";
case BuiltInPointSize:
return "gl_PointSize";
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
case BuiltInClipDistance:
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
{
if (options.es)
require_extension_internal("GL_EXT_clip_cull_distance");
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
return "gl_ClipDistance";
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
}
Add built-in cull distance.
2017-03-05 11:44:29 +00:00
case BuiltInCullDistance:
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
{
if (options.es)
require_extension_internal("GL_EXT_clip_cull_distance");
Add built-in cull distance.
2017-03-05 11:44:29 +00:00
return "gl_CullDistance";
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInVertexId:
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
if (options.vulkan_semantics)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Cannot implement gl_VertexID in Vulkan GLSL. This shader was created "
"with GL semantics.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "gl_VertexID";
case BuiltInInstanceId:
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
if (options.vulkan_semantics)
Support gl_InstanceID in RT shaders.
2020-05-08 11:39:43 +00:00
{
auto model = get_entry_point().model;
switch (model)
{
case spv::ExecutionModelIntersectionKHR:
case spv::ExecutionModelAnyHitKHR:
case spv::ExecutionModelClosestHitKHR:
// gl_InstanceID is allowed in these shaders.
break;
default:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Cannot implement gl_InstanceID in Vulkan GLSL. This shader was "
"created with GL semantics.");
Support gl_InstanceID in RT shaders.
2020-05-08 11:39:43 +00:00
}
}
GLSL: Require GL_ARB_draw_instanced for gl_InstanceID in GLSL < 1.40
2020-06-12 20:42:26 +00:00
if (!options.es && options.version < 140)
{
require_extension_internal("GL_ARB_draw_instanced");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "gl_InstanceID";
case BuiltInVertexIndex:
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
if (options.vulkan_semantics)
return "gl_VertexIndex";
else
return "gl_VertexID"; // gl_VertexID already has the base offset applied.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInInstanceIndex:
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
if (options.vulkan_semantics)
return "gl_InstanceIndex";
GLSL: Require GL_ARB_draw_instanced for gl_InstanceID in GLSL < 1.40
2020-06-12 20:42:26 +00:00
if (!options.es && options.version < 140)
{
require_extension_internal("GL_ARB_draw_instanced");
}
if (options.vertex.support_nonzero_base_instance)
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
{
if (!options.vulkan_semantics)
{
// This is a soft-enable. We will opt-in to using gl_BaseInstanceARB if supported.
require_extension_internal("GL_ARB_shader_draw_parameters");
}
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
return "(gl_InstanceID + SPIRV_Cross_BaseInstance)"; // ... but not gl_InstanceID.
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
}
Add support to remove SPIRV_Cross_BaseInstance uniform.
2018-06-22 08:01:38 +00:00
else
return "gl_InstanceID";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInPrimitiveId:
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
if (storage == StorageClassInput && get_entry_point().model == ExecutionModelGeometry)
return "gl_PrimitiveIDIn";
else
return "gl_PrimitiveID";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInInvocationId:
return "gl_InvocationID";
case BuiltInLayer:
return "gl_Layer";
Support ViewportIndex builtin.
2018-01-04 11:41:25 +00:00
case BuiltInViewportIndex:
return "gl_ViewportIndex";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInTessLevelOuter:
return "gl_TessLevelOuter";
case BuiltInTessLevelInner:
return "gl_TessLevelInner";
case BuiltInTessCoord:
return "gl_TessCoord";
MSL: Fix patch vertex count with raw buffer tese input. We can no longer rely on the `patch_control_point<>` array being present, so the best we can do is use the value given us at compile time. This was an oversight on my part when I initially implemented the raw-buffer tessellation evaluation input mode. The lack of tests for the `PatchVertices` built-in almost certainly contributed, so I fixed that in this patch. Fixes the test `dEQP-VK.tessellation.shader_input_output.patch_vertices_in_tes`. This is the last failing test under `dEQP-VK.tessellation`.
2023-12-04 09:42:48 +00:00
case BuiltInPatchVertices:
return "gl_PatchVerticesIn";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case BuiltInFragCoord:
return "gl_FragCoord";
case BuiltInPointCoord:
return "gl_PointCoord";
case BuiltInFrontFacing:
return "gl_FrontFacing";
case BuiltInFragDepth:
return "gl_FragDepth";
case BuiltInNumWorkgroups:
return "gl_NumWorkGroups";
case BuiltInWorkgroupSize:
return "gl_WorkGroupSize";
case BuiltInWorkgroupId:
return "gl_WorkGroupID";
case BuiltInLocalInvocationId:
return "gl_LocalInvocationID";
case BuiltInGlobalInvocationId:
return "gl_GlobalInvocationID";
case BuiltInLocalInvocationIndex:
return "gl_LocalInvocationIndex";
Support gl_HelperInvocation on GLSL and MSL. There is no obvious builtin for this on HLSL.
2018-11-28 14:18:43 +00:00
case BuiltInHelperInvocation:
return "gl_HelperInvocation";
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseVertex:
if (options.es)
SPIRV_CROSS_THROW("BaseVertex not supported in ES profile.");
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
if (options.vulkan_semantics)
{
if (options.version < 460)
{
require_extension_internal("GL_ARB_shader_draw_parameters");
return "gl_BaseVertexARB";
}
return "gl_BaseVertex";
}
Fix -Wunreachable-code-aggressive. Bug: chromium:1066980
2021-06-30 16:17:59 +00:00
// On regular GL, this is soft-enabled and we emit ifdefs in code.
require_extension_internal("GL_ARB_shader_draw_parameters");
return "SPIRV_Cross_BaseVertex";
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseInstance:
if (options.es)
SPIRV_CROSS_THROW("BaseInstance not supported in ES profile.");
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
if (options.vulkan_semantics)
Fix formatting.
2018-08-29 15:08:33 +00:00
{
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
if (options.version < 460)
{
require_extension_internal("GL_ARB_shader_draw_parameters");
return "gl_BaseInstanceARB";
}
return "gl_BaseInstance";
}
Fix -Wunreachable-code-aggressive. Bug: chromium:1066980
2021-06-30 16:17:59 +00:00
// On regular GL, this is soft-enabled and we emit ifdefs in code.
require_extension_internal("GL_ARB_shader_draw_parameters");
return "SPIRV_Cross_BaseInstance";
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInDrawIndex:
if (options.es)
SPIRV_CROSS_THROW("DrawIndex not supported in ES profile.");
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
if (options.vulkan_semantics)
Fix formatting.
2018-08-29 15:08:33 +00:00
{
GLSL: Improve support for GL_ARB_shader_draw_parameters in desktop GLSL. Opt-in to using the extension to support gl_InstanceIndex.
2020-05-22 10:44:56 +00:00
if (options.version < 460)
{
require_extension_internal("GL_ARB_shader_draw_parameters");
return "gl_DrawIDARB";
}
return "gl_DrawID";
}
Fix -Wunreachable-code-aggressive. Bug: chromium:1066980
2021-06-30 16:17:59 +00:00
// On regular GL, this is soft-enabled and we emit ifdefs in code.
require_extension_internal("GL_ARB_shader_draw_parameters");
return "gl_DrawIDARB";
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
case BuiltInSampleId:
GLSL: Allow sample inputs in desktop < 400 with GL_ARB_sample_shading Neither legacy ES nor legacy desktop support these extensions
2023-01-23 13:50:57 +00:00
if (is_legacy())
SPIRV_CROSS_THROW("Sample variables not supported in legacy GLSL.");
else if (options.es && options.version < 320)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_OES_sample_variables");
GLSL: Allow sample inputs in desktop < 400 with GL_ARB_sample_shading Neither legacy ES nor legacy desktop support these extensions
2023-01-23 13:50:57 +00:00
else if (!options.es && options.version < 400)
require_extension_internal("GL_ARB_sample_shading");
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
return "gl_SampleID";
case BuiltInSampleMask:
GLSL: Allow sample inputs in desktop < 400 with GL_ARB_sample_shading Neither legacy ES nor legacy desktop support these extensions
2023-01-23 13:50:57 +00:00
if (is_legacy())
SPIRV_CROSS_THROW("Sample variables not supported in legacy GLSL.");
else if (options.es && options.version < 320)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_OES_sample_variables");
GLSL: Allow sample inputs in desktop < 400 with GL_ARB_sample_shading Neither legacy ES nor legacy desktop support these extensions
2023-01-23 13:50:57 +00:00
else if (!options.es && options.version < 400)
require_extension_internal("GL_ARB_sample_shading");
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
if (storage == StorageClassInput)
return "gl_SampleMaskIn";
else
return "gl_SampleMask";
case BuiltInSamplePosition:
GLSL: Allow sample inputs in desktop < 400 with GL_ARB_sample_shading Neither legacy ES nor legacy desktop support these extensions
2023-01-23 13:50:57 +00:00
if (is_legacy())
SPIRV_CROSS_THROW("Sample variables not supported in legacy GLSL.");
else if (options.es && options.version < 320)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_OES_sample_variables");
GLSL: Allow sample inputs in desktop < 400 with GL_ARB_sample_shading Neither legacy ES nor legacy desktop support these extensions
2023-01-23 13:50:57 +00:00
else if (!options.es && options.version < 400)
require_extension_internal("GL_ARB_sample_shading");
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
return "gl_SamplePosition";
Add support for SPV_KHR_multiview.
2017-08-15 11:28:16 +00:00
case BuiltInViewIndex:
if (options.vulkan_semantics)
return "gl_ViewIndex";
else
return "gl_ViewID_OVR";
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case BuiltInNumSubgroups:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::NumSubgroups);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
return "gl_NumSubgroups";
case BuiltInSubgroupId:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupID);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
return "gl_SubgroupID";
case BuiltInSubgroupSize:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupSize);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
return "gl_SubgroupSize";
case BuiltInSubgroupLocalInvocationId:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupInvocationID);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
return "gl_SubgroupInvocationID";
case BuiltInSubgroupEqMask:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
return "gl_SubgroupEqMask";
case BuiltInSubgroupGeMask:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
return "gl_SubgroupGeMask";
case BuiltInSubgroupGtMask:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
return "gl_SubgroupGtMask";
case BuiltInSubgroupLeMask:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
return "gl_SubgroupLeMask";
case BuiltInSubgroupLtMask:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMask);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
return "gl_SubgroupLtMask";
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
case BuiltInLaunchIdKHR:
return ray_tracing_is_khr ? "gl_LaunchIDEXT" : "gl_LaunchIDNV";
case BuiltInLaunchSizeKHR:
return ray_tracing_is_khr ? "gl_LaunchSizeEXT" : "gl_LaunchSizeNV";
case BuiltInWorldRayOriginKHR:
return ray_tracing_is_khr ? "gl_WorldRayOriginEXT" : "gl_WorldRayOriginNV";
case BuiltInWorldRayDirectionKHR:
return ray_tracing_is_khr ? "gl_WorldRayDirectionEXT" : "gl_WorldRayDirectionNV";
case BuiltInObjectRayOriginKHR:
return ray_tracing_is_khr ? "gl_ObjectRayOriginEXT" : "gl_ObjectRayOriginNV";
case BuiltInObjectRayDirectionKHR:
return ray_tracing_is_khr ? "gl_ObjectRayDirectionEXT" : "gl_ObjectRayDirectionNV";
case BuiltInRayTminKHR:
return ray_tracing_is_khr ? "gl_RayTminEXT" : "gl_RayTminNV";
case BuiltInRayTmaxKHR:
return ray_tracing_is_khr ? "gl_RayTmaxEXT" : "gl_RayTmaxNV";
case BuiltInInstanceCustomIndexKHR:
return ray_tracing_is_khr ? "gl_InstanceCustomIndexEXT" : "gl_InstanceCustomIndexNV";
case BuiltInObjectToWorldKHR:
return ray_tracing_is_khr ? "gl_ObjectToWorldEXT" : "gl_ObjectToWorldNV";
case BuiltInWorldToObjectKHR:
return ray_tracing_is_khr ? "gl_WorldToObjectEXT" : "gl_WorldToObjectNV";
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
case BuiltInHitTNV:
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
// gl_HitTEXT is an alias of RayTMax in KHR.
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
return "gl_HitTNV";
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
case BuiltInHitKindKHR:
return ray_tracing_is_khr ? "gl_HitKindEXT" : "gl_HitKindNV";
case BuiltInIncomingRayFlagsKHR:
return ray_tracing_is_khr ? "gl_IncomingRayFlagsEXT" : "gl_IncomingRayFlagsNV";
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
Emit KHR barycentrics if source enables the KHR extension. For roundtrip purposes, need to match KHR or NV extension.
2022-05-27 11:27:48 +00:00
case BuiltInBaryCoordKHR:
GLSL: Support NV barycentrics.
2019-06-13 09:33:19 +00:00
{
if (options.es && options.version < 320)
Emit KHR barycentrics if source enables the KHR extension. For roundtrip purposes, need to match KHR or NV extension.
2022-05-27 11:27:48 +00:00
SPIRV_CROSS_THROW("gl_BaryCoordEXT requires ESSL 320.");
GLSL: Support NV barycentrics.
2019-06-13 09:33:19 +00:00
else if (!options.es && options.version < 450)
Emit KHR barycentrics if source enables the KHR extension. For roundtrip purposes, need to match KHR or NV extension.
2022-05-27 11:27:48 +00:00
SPIRV_CROSS_THROW("gl_BaryCoordEXT requires GLSL 450.");
if (barycentric_is_nv)
{
require_extension_internal("GL_NV_fragment_shader_barycentric");
return "gl_BaryCoordNV";
}
else
{
require_extension_internal("GL_EXT_fragment_shader_barycentric");
return "gl_BaryCoordEXT";
}
GLSL: Support NV barycentrics.
2019-06-13 09:33:19 +00:00
}
case BuiltInBaryCoordNoPerspNV:
{
if (options.es && options.version < 320)
Emit KHR barycentrics if source enables the KHR extension. For roundtrip purposes, need to match KHR or NV extension.
2022-05-27 11:27:48 +00:00
SPIRV_CROSS_THROW("gl_BaryCoordNoPerspEXT requires ESSL 320.");
GLSL: Support NV barycentrics.
2019-06-13 09:33:19 +00:00
else if (!options.es && options.version < 450)
Emit KHR barycentrics if source enables the KHR extension. For roundtrip purposes, need to match KHR or NV extension.
2022-05-27 11:27:48 +00:00
SPIRV_CROSS_THROW("gl_BaryCoordNoPerspEXT requires GLSL 450.");
if (barycentric_is_nv)
{
require_extension_internal("GL_NV_fragment_shader_barycentric");
return "gl_BaryCoordNoPerspNV";
}
else
{
require_extension_internal("GL_EXT_fragment_shader_barycentric");
return "gl_BaryCoordNoPerspEXT";
}
GLSL: Support NV barycentrics.
2019-06-13 09:33:19 +00:00
}
GLSL: Support GL_ARB_shader_stencil_export.
2019-06-12 07:57:32 +00:00
case BuiltInFragStencilRefEXT:
{
if (!options.es)
{
require_extension_internal("GL_ARB_shader_stencil_export");
return "gl_FragStencilRefARB";
}
else
SPIRV_CROSS_THROW("Stencil export not supported in GLES.");
}
GLSL: Support shading rate builtins.
2021-04-20 11:58:07 +00:00
case BuiltInPrimitiveShadingRateKHR:
{
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Can only use PrimitiveShadingRateKHR in Vulkan GLSL.");
require_extension_internal("GL_EXT_fragment_shading_rate");
return "gl_PrimitiveShadingRateEXT";
}
case BuiltInShadingRateKHR:
{
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Can only use ShadingRateKHR in Vulkan GLSL.");
require_extension_internal("GL_EXT_fragment_shading_rate");
return "gl_ShadingRateEXT";
}
Support the SPV_KHR_device_group extension. The only piece added by this extension is the `DeviceIndex` builtin, which tells the shader which device in a grouped logical device it is running on. Metal's pipeline state objects are owned by the `MTLDevice` that created them. Since Metal doesn't support logical grouping of devices the way Vulkan does, we'll thus have to create a pipeline state for each device in a grouped logical device. The upcoming peer group support in Metal 3 will not change this. For this reason, for Metal, the device index is supplied as a constant at pipeline compile time. There's an interaction between `VK_KHR_device_group` and `VK_KHR_multiview` in the `VK_PIPELINE_CREATE_VIEW_INDEX_FROM_DEVICE_INDEX_BIT`, which defines the view index to be the same as the device index. The new `view_index_from_device_index` MSL option supports this functionality.
2019-07-13 02:50:50 +00:00
case BuiltInDeviceIndex:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for device group support.");
require_extension_internal("GL_EXT_device_group");
return "gl_DeviceIndex";
GLSL: Implement gl_FragFullyCoveredNV.
2021-04-20 11:44:52 +00:00
case BuiltInFullyCoveredEXT:
if (!options.es)
require_extension_internal("GL_NV_conservative_raster_underestimation");
else
SPIRV_CROSS_THROW("Need desktop GL to use GL_NV_conservative_raster_underestimation.");
return "gl_FragFullyCoveredNV";
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
case BuiltInPrimitiveTriangleIndicesEXT:
return "gl_PrimitiveTriangleIndicesEXT";
case BuiltInPrimitiveLineIndicesEXT:
return "gl_PrimitiveLineIndicesEXT";
case BuiltInPrimitivePointIndicesEXT:
return "gl_PrimitivePointIndicesEXT";
case BuiltInCullPrimitiveEXT:
return "gl_CullPrimitiveEXT";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
Add support for the BuiltInClipDistance builtin for MSL. CompilerGLSL builtin_to_glsl() function outputs gl_ClipDistance for BuiltInClipDistance builtin, and includes builtin code in output when handling unknown builtin code. CompilerMSL uses type ID instead of type object where appropriate to support array types, where type.self is not consistent with actual type ID, plus support array stride calc even when not explicitly set by SPIR-V code. For output consistency, CompilerMSL prefers use of standard builtin names over specified names, and output builtins qualified with output struct while in entry function.
2016-12-17 22:07:53 +00:00
return join("gl_BuiltIn_", convert_to_string(builtin));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
const char *CompilerGLSL::index_to_swizzle(uint32_t index)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (index)
{
case 0:
return "x";
case 1:
return "y";
case 2:
return "z";
case 3:
return "w";
default:
Per spec, support undefined behavior for out-of-bounds swizzles. Per spec, instead of throwing exception for out-of-bounds swizzles, engage undefined behavior by defaulting to the .x swizzle.
2021-10-20 18:46:30 +00:00
return "x"; // Don't crash, but engage the "undefined behavior" described for out-of-bounds logical addressing in spec.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
void CompilerGLSL::access_chain_internal_append_index(std::string &expr, uint32_t /*base*/, const SPIRType * /*type*/,
MSL: Support OpPtrEqual, OpPtrNotEqual, and OpPtrDiff. - Add CompilerMSL::emit_binary_ptr_op() and to_ptr_expression() to emit binary pointer op. Compare matrix addresses without automatic transpose() conversion, to avoid error taking address of temporary copy. - Add Compiler::add_active_interface_variable() to also track active interface vars in the entry point for SPIR-V 1.4 and above. - For OpPtrAccessChain that ends in array element, use Element as offset to existing index, otherwise it will access into array dimension that doesn't exist. - Dereference pointer function call arguments. Ultimately, this dereferencing is actually backwards, and in future, we should aim to properly support passing pointer variables between functions, but such a refactoring was beyond the scope here. - Use [] to declare array of pointers, as array<T*> is not supported in MSL. - Add unit test shaders.
2022-09-14 19:19:15 +00:00
AccessChainFlags flags, bool &access_chain_is_arrayed,
Simplified overriding of 'access_chain_internal' function in CompilerMSL.
2019-10-22 15:06:16 +00:00
uint32_t index)
{
bool index_is_literal = (flags & ACCESS_CHAIN_INDEX_IS_LITERAL_BIT) != 0;
MSL: Support OpPtrEqual, OpPtrNotEqual, and OpPtrDiff. - Add CompilerMSL::emit_binary_ptr_op() and to_ptr_expression() to emit binary pointer op. Compare matrix addresses without automatic transpose() conversion, to avoid error taking address of temporary copy. - Add Compiler::add_active_interface_variable() to also track active interface vars in the entry point for SPIR-V 1.4 and above. - For OpPtrAccessChain that ends in array element, use Element as offset to existing index, otherwise it will access into array dimension that doesn't exist. - Dereference pointer function call arguments. Ultimately, this dereferencing is actually backwards, and in future, we should aim to properly support passing pointer variables between functions, but such a refactoring was beyond the scope here. - Use [] to declare array of pointers, as array<T*> is not supported in MSL. - Add unit test shaders.
2022-09-14 19:19:15 +00:00
bool ptr_chain = (flags & ACCESS_CHAIN_PTR_CHAIN_BIT) != 0;
Simplified overriding of 'access_chain_internal' function in CompilerMSL.
2019-10-22 15:06:16 +00:00
bool register_expression_read = (flags & ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT) == 0;
MSL: Support OpPtrEqual, OpPtrNotEqual, and OpPtrDiff. - Add CompilerMSL::emit_binary_ptr_op() and to_ptr_expression() to emit binary pointer op. Compare matrix addresses without automatic transpose() conversion, to avoid error taking address of temporary copy. - Add Compiler::add_active_interface_variable() to also track active interface vars in the entry point for SPIR-V 1.4 and above. - For OpPtrAccessChain that ends in array element, use Element as offset to existing index, otherwise it will access into array dimension that doesn't exist. - Dereference pointer function call arguments. Ultimately, this dereferencing is actually backwards, and in future, we should aim to properly support passing pointer variables between functions, but such a refactoring was beyond the scope here. - Use [] to declare array of pointers, as array<T*> is not supported in MSL. - Add unit test shaders.
2022-09-14 19:19:15 +00:00
string idx_expr = index_is_literal ? convert_to_string(index) : to_unpacked_expression(index, register_expression_read);
Simplified overriding of 'access_chain_internal' function in CompilerMSL.
2019-10-22 15:06:16 +00:00
MSL: Support OpPtrEqual, OpPtrNotEqual, and OpPtrDiff. - Add CompilerMSL::emit_binary_ptr_op() and to_ptr_expression() to emit binary pointer op. Compare matrix addresses without automatic transpose() conversion, to avoid error taking address of temporary copy. - Add Compiler::add_active_interface_variable() to also track active interface vars in the entry point for SPIR-V 1.4 and above. - For OpPtrAccessChain that ends in array element, use Element as offset to existing index, otherwise it will access into array dimension that doesn't exist. - Dereference pointer function call arguments. Ultimately, this dereferencing is actually backwards, and in future, we should aim to properly support passing pointer variables between functions, but such a refactoring was beyond the scope here. - Use [] to declare array of pointers, as array<T*> is not supported in MSL. - Add unit test shaders.
2022-09-14 19:19:15 +00:00
// For the case where the base of an OpPtrAccessChain already ends in [n],
// we need to use the index as an offset to the existing index, otherwise,
// we can just use the index directly.
if (ptr_chain && access_chain_is_arrayed)
{
size_t split_pos = expr.find_last_of(']');
MSL: Consider PtrAccessChain on array types.
2023-12-06 13:30:13 +00:00
size_t enclose_split = expr.find_last_of(')');
// If we have already enclosed the expression, don't try to be clever, it will break.
if (split_pos > enclose_split || enclose_split == string::npos)
{
string expr_front = expr.substr(0, split_pos);
string expr_back = expr.substr(split_pos);
expr = expr_front + " + " + enclose_expression(idx_expr) + expr_back;
return;
}
MSL: Support OpPtrEqual, OpPtrNotEqual, and OpPtrDiff. - Add CompilerMSL::emit_binary_ptr_op() and to_ptr_expression() to emit binary pointer op. Compare matrix addresses without automatic transpose() conversion, to avoid error taking address of temporary copy. - Add Compiler::add_active_interface_variable() to also track active interface vars in the entry point for SPIR-V 1.4 and above. - For OpPtrAccessChain that ends in array element, use Element as offset to existing index, otherwise it will access into array dimension that doesn't exist. - Dereference pointer function call arguments. Ultimately, this dereferencing is actually backwards, and in future, we should aim to properly support passing pointer variables between functions, but such a refactoring was beyond the scope here. - Use [] to declare array of pointers, as array<T*> is not supported in MSL. - Add unit test shaders.
2022-09-14 19:19:15 +00:00
}
MSL: Consider PtrAccessChain on array types.
2023-12-06 13:30:13 +00:00
expr += "[";
expr += idx_expr;
expr += "]";
Simplified overriding of 'access_chain_internal' function in CompilerMSL.
2019-10-22 15:06:16 +00:00
}
MSL: Handle loading Clip/CullDistance in TESE. Need to allow the flattened space to go through in some edge cases where we cannot reasonably unflatten.
2021-04-14 13:10:02 +00:00
bool CompilerGLSL::access_chain_needs_stage_io_builtin_translation(uint32_t)
{
return true;
}
Run format_all.sh.
2017-02-23 18:33:14 +00:00
string CompilerGLSL::access_chain_internal(uint32_t base, const uint32_t *indices, uint32_t count,
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
AccessChainFlags flags, AccessChainMeta *meta)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string expr;
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
bool index_is_literal = (flags & ACCESS_CHAIN_INDEX_IS_LITERAL_BIT) != 0;
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
bool msb_is_id = (flags & ACCESS_CHAIN_LITERAL_MSB_FORCE_ID) != 0;
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
bool chain_only = (flags & ACCESS_CHAIN_CHAIN_ONLY_BIT) != 0;
bool ptr_chain = (flags & ACCESS_CHAIN_PTR_CHAIN_BIT) != 0;
bool register_expression_read = (flags & ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT) == 0;
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
bool flatten_member_reference = (flags & ACCESS_CHAIN_FLATTEN_ALL_MEMBERS_BIT) != 0;
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!chain_only)
Deal correctly with non-forwarded packed loads. Need to unpack the expression if we're not forwarding.
2019-07-23 14:25:19 +00:00
{
// We handle transpose explicitly, so don't resolve that here.
auto *e = maybe_get<SPIRExpression>(base);
bool old_transpose = e && e->need_transpose;
if (e)
e->need_transpose = false;
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
expr = to_enclosed_expression(base, register_expression_read);
Deal correctly with non-forwarded packed loads. Need to unpack the expression if we're not forwarding.
2019-07-23 14:25:19 +00:00
if (e)
e->need_transpose = old_transpose;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Fix issue #245: assignment of flattened input struct. Emit input struct assignment by assigning member by member from stage_in struct. Map qualified member name from pointer type, not base type. Add Comiler::expression_type_id() function, similar to expression_type().
2017-08-12 04:21:13 +00:00
// Start traversing type hierarchy at the proper non-pointer types,
// but keep type_id referencing the original pointer for use below.
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
uint32_t type_id = expression_type_id(base);
MSL: Defererence pointer expressions before traversing access chain. Exception is struct which does -> for us.
2023-12-06 14:29:51 +00:00
const auto *type = &get_pointee_type(type_id);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
if (!backend.native_pointers)
{
if (ptr_chain)
SPIRV_CROSS_THROW("Backend does not support native pointers and does not support OpPtrAccessChain.");
// Wrapped buffer reference pointer types will need to poke into the internal "value" member before
// continuing the access chain.
if (should_dereference(base))
MSL: Defererence pointer expressions before traversing access chain. Exception is struct which does -> for us.
2023-12-06 14:29:51 +00:00
expr = dereference_expression(get<SPIRType>(type_id), expr);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
}
MSL: Defererence pointer expressions before traversing access chain. Exception is struct which does -> for us.
2023-12-06 14:29:51 +00:00
else if (should_dereference(base) && type->basetype != SPIRType::Struct && !ptr_chain)
MSL: Wrap dereferenced ptr-chain expressions.
2023-12-06 16:02:44 +00:00
expr = join("(", dereference_expression(*type, expr), ")");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Fix split access chains for builtin arrays.
2018-05-08 13:33:51 +00:00
bool access_chain_is_arrayed = expr.find_first_of('[') != string::npos;
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
bool row_major_matrix_needs_conversion = is_non_native_row_major_matrix(base);
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
bool is_packed = has_extended_decoration(base, SPIRVCrossDecorationPhysicalTypePacked);
uint32_t physical_type = get_extended_decoration(base, SPIRVCrossDecorationPhysicalTypeID);
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
bool is_invariant = has_decoration(base, DecorationInvariant);
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
bool relaxed_precision = has_decoration(base, DecorationRelaxedPrecision);
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
bool pending_array_enclose = false;
Add multidimensional array flattening test.
2017-05-22 15:40:00 +00:00
bool dimension_flatten = false;
track access to meshlet position.y, via SPIRExpression
2023-07-01 13:49:35 +00:00
bool access_meshlet_position_y = false;
if (auto *base_expr = maybe_get<SPIRExpression>(base))
{
access_meshlet_position_y = base_expr->access_meshlet_position_y;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
HLSL: Add support to preserve (RW)StructuredBuffer resources.
2023-05-02 21:36:43 +00:00
// If we are translating access to a structured buffer, the first subscript '._m0' must be hidden
bool hide_first_subscript = count > 1 && is_user_type_structured(base);
MSL: Support OpPtrEqual, OpPtrNotEqual, and OpPtrDiff. - Add CompilerMSL::emit_binary_ptr_op() and to_ptr_expression() to emit binary pointer op. Compare matrix addresses without automatic transpose() conversion, to avoid error taking address of temporary copy. - Add Compiler::add_active_interface_variable() to also track active interface vars in the entry point for SPIR-V 1.4 and above. - For OpPtrAccessChain that ends in array element, use Element as offset to existing index, otherwise it will access into array dimension that doesn't exist. - Dereference pointer function call arguments. Ultimately, this dereferencing is actually backwards, and in future, we should aim to properly support passing pointer variables between functions, but such a refactoring was beyond the scope here. - Use [] to declare array of pointers, as array<T*> is not supported in MSL. - Add unit test shaders.
2022-09-14 19:19:15 +00:00
const auto append_index = [&](uint32_t index, bool is_literal, bool is_ptr_chain = false) {
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
AccessChainFlags mod_flags = flags;
if (!is_literal)
mod_flags &= ~ACCESS_CHAIN_INDEX_IS_LITERAL_BIT;
MSL: Support OpPtrEqual, OpPtrNotEqual, and OpPtrDiff. - Add CompilerMSL::emit_binary_ptr_op() and to_ptr_expression() to emit binary pointer op. Compare matrix addresses without automatic transpose() conversion, to avoid error taking address of temporary copy. - Add Compiler::add_active_interface_variable() to also track active interface vars in the entry point for SPIR-V 1.4 and above. - For OpPtrAccessChain that ends in array element, use Element as offset to existing index, otherwise it will access into array dimension that doesn't exist. - Dereference pointer function call arguments. Ultimately, this dereferencing is actually backwards, and in future, we should aim to properly support passing pointer variables between functions, but such a refactoring was beyond the scope here. - Use [] to declare array of pointers, as array<T*> is not supported in MSL. - Add unit test shaders.
2022-09-14 19:19:15 +00:00
if (!is_ptr_chain)
mod_flags &= ~ACCESS_CHAIN_PTR_CHAIN_BIT;
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
access_chain_internal_append_index(expr, base, type, mod_flags, access_chain_is_arrayed, index);
MSL: Fixes from review for SPV_KHR_physical_storage_buffer extension. - Assign ulongn physical type to buffer pointers in short arrays when array stride is larger than pointer size. - Support GL_EXT_buffer_reference_uvec2 casting buffer reference pointers to and from uvec2 values. - When packing structs, include structs inside physical buffers. - Update mechanism for traversing pointer arrays when calculating type sizes. - Added unit test shaders.
2022-07-01 20:10:41 +00:00
check_physical_type_cast(expr, type, physical_type);
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
};
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (uint32_t i = 0; i < count; i++)
{
uint32_t index = indices[i];
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
bool is_literal = index_is_literal;
if (is_literal && msb_is_id && (index >> 31u) != 0u)
{
is_literal = false;
index &= 0x7fffffffu;
}
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
bool ptr_chain_array_entry = ptr_chain && i == 0 && is_array(*type);
MSL: Consider PtrAccessChain on array types.
2023-12-06 13:30:13 +00:00
if (ptr_chain_array_entry)
{
// This is highly unusual code, since normally we'd use plain AccessChain, but it's still allowed.
// We are considered to have a pointer to array and one element shifts by one array at a time.
// If we use normal array indexing, we'll first decay to pointer, and lose the array-ness,
// so we have to take pointer to array explicitly.
MSL: Only do address-of expression when needed.
2023-12-06 14:01:32 +00:00
if (!should_dereference(base))
expr = enclose_expression(address_of_expression(expr));
MSL: Consider PtrAccessChain on array types.
2023-12-06 13:30:13 +00:00
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
if (ptr_chain && i == 0)
{
MSL: Consider PtrAccessChain on array types.
2023-12-06 13:30:13 +00:00
// Pointer chains
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// If we are flattening multidimensional arrays, only create opening bracket on first
// array index.
if (options.flatten_multidimensional_arrays)
{
dimension_flatten = type->array.size() >= 1;
pending_array_enclose = dimension_flatten;
if (pending_array_enclose)
expr += "[";
}
if (options.flatten_multidimensional_arrays && dimension_flatten)
{
// If we are flattening multidimensional arrays, do manual stride computation.
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
if (is_literal)
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
expr += convert_to_string(index);
else
expr += to_enclosed_expression(index, register_expression_read);
for (auto j = uint32_t(type->array.size()); j; j--)
{
expr += " * ";
expr += enclose_expression(to_array_size(*type, j - 1));
}
if (type->array.empty())
pending_array_enclose = false;
else
expr += " + ";
if (!pending_array_enclose)
expr += "]";
}
else
{
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
if (flags & ACCESS_CHAIN_PTR_CHAIN_POINTER_ARITH_BIT)
{
SPIRType tmp_type(OpTypeInt);
tmp_type.basetype = SPIRType::UInt64;
tmp_type.width = 64;
tmp_type.vecsize = 1;
tmp_type.columns = 1;
TypeID ptr_type_id = expression_type_id(base);
const SPIRType &ptr_type = get<SPIRType>(ptr_type_id);
MSL: Cast to packed format when using unexpected stride. We're still technically missing handling for Aligned mask on Load/Store, but that needs separate analysis and gets horribly annoying ... This should cover most use cases.
2024-06-19 12:24:50 +00:00
const SPIRType &pointee_type = get_pointee_type(ptr_type);
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
// This only runs in native pointer backends.
// Can replace reinterpret_cast with a backend string if ever needed.
// We expect this to count as a de-reference.
MSL: Cast to packed format when using unexpected stride. We're still technically missing handling for Aligned mask on Load/Store, but that needs separate analysis and gets horribly annoying ... This should cover most use cases.
2024-06-19 12:24:50 +00:00
// This leaks some MSL details, but feels slightly overkill to
// add yet another virtual interface just for this.
auto intptr_expr = join("reinterpret_cast<", type_to_glsl(tmp_type), ">(", expr, ")");
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
intptr_expr += join(" + ", to_enclosed_unpacked_expression(index), " * ",
MSL: Fix indent.
2024-06-19 12:45:24 +00:00
get_decoration(ptr_type_id, DecorationArrayStride));
MSL: Cast to packed format when using unexpected stride. We're still technically missing handling for Aligned mask on Load/Store, but that needs separate analysis and gets horribly annoying ... This should cover most use cases.
2024-06-19 12:24:50 +00:00
if (flags & ACCESS_CHAIN_PTR_CHAIN_CAST_TO_SCALAR_BIT)
{
is_packed = true;
expr = join("*reinterpret_cast<device packed_", type_to_glsl(pointee_type),
MSL: Fix indent.
2024-06-19 12:45:24 +00:00
" *>(", intptr_expr, ")");
MSL: Cast to packed format when using unexpected stride. We're still technically missing handling for Aligned mask on Load/Store, but that needs separate analysis and gets horribly annoying ... This should cover most use cases.
2024-06-19 12:24:50 +00:00
}
else
{
expr = join("*reinterpret_cast<", type_to_glsl(ptr_type), ">(", intptr_expr, ")");
}
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
}
else
append_index(index, is_literal, true);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
}
MSL: Add support for tessellation evaluation shaders. These are mapped to Metal's post-tessellation vertex functions. The semantic difference is much less here, so this change should be simpler than the previous one. There are still some hairy parts, though. In MSL, the array of control point data is represented by a special type, `patch_control_point<T>`, where `T` is a valid stage-input type. This object must be embedded inside the patch-level stage input. For this reason, I've added a new type to the type system to represent this. On Mac, the number of input control points to the function must be specified in the `patch()` attribute. This is optional on iOS. SPIRV-Cross takes this from the `OutputVertices` execution mode; the intent is that if it's not set in the shader itself, MoltenVK will set it from the tessellation control shader. If you're translating these offline, you'll have to update the control point count manually, since this number must match the number that is passed to the `drawPatches:...` family of methods. Fixes #120.
2019-02-06 00:13:26 +00:00
if (type->basetype == SPIRType::ControlPointArray)
{
type_id = type->parent_type;
type = &get<SPIRType>(type_id);
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
access_chain_is_arrayed = true;
MSL: Consider PtrAccessChain on array types.
2023-12-06 13:30:13 +00:00
// Explicitly enclose the expression if this is one of the weird pointer-to-array cases.
// We don't want any future indexing to add to this array dereference.
// Enclosing the expression blocks that and avoids any shenanigans with operand priority.
if (ptr_chain_array_entry)
expr = join("(", expr, ")");
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Arrays
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
else if (!type->array.empty())
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
// If we are flattening multidimensional arrays, only create opening bracket on first
// array index.
if (options.flatten_multidimensional_arrays && !pending_array_enclose)
{
Add multidimensional array flattening test.
2017-05-22 15:40:00 +00:00
dimension_flatten = type->array.size() > 1;
pending_array_enclose = dimension_flatten;
if (pending_array_enclose)
expr += "[";
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Add traversal for active builtin variables. Refactor some ugly type-copying for access chains.
2017-03-06 14:21:00 +00:00
assert(type->parent_type);
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
auto *var = maybe_get<SPIRVariable>(base);
Revert to not forcing gl_in/gl_out block for MSL, and add MSL gl_ClipDistance tests.
2018-01-08 21:18:34 +00:00
if (backend.force_gl_in_out_block && i == 0 && var && is_builtin_variable(*var) &&
!has_decoration(type->self, DecorationBlock))
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
{
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
// This deals with scenarios for tesc/geom where arrays of gl_Position[] are declared.
// Normally, these variables live in blocks when compiled from GLSL,
// but HLSL seems to just emit straight arrays here.
// We must pretend this access goes through gl_in/gl_out arrays
// to be able to access certain builtins as arrays.
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
// Similar concerns apply for mesh shaders where we have to redirect to gl_MeshVerticesEXT or MeshPrimitivesEXT.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto builtin = ir.meta[base].decoration.builtin_type;
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
bool mesh_shader = get_execution_model() == ExecutionModelMeshEXT;
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
switch (builtin)
{
GLSL: Fix Clip/Cull in mesh shaders.
2023-08-25 09:50:19 +00:00
case BuiltInCullDistance:
case BuiltInClipDistance:
if (type->array.size() == 1) // Red herring. Only consider block IO for two-dimensional arrays here.
{
append_index(index, is_literal);
break;
}
// fallthrough
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
case BuiltInPosition:
case BuiltInPointSize:
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if (mesh_shader)
expr = join("gl_MeshVerticesEXT[", to_expression(index, register_expression_read), "].", expr);
else if (var->storage == StorageClassInput)
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
expr = join("gl_in[", to_expression(index, register_expression_read), "].", expr);
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
else if (var->storage == StorageClassOutput)
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
expr = join("gl_out[", to_expression(index, register_expression_read), "].", expr);
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
else
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
append_index(index, is_literal);
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
break;
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
case BuiltInPrimitiveId:
case BuiltInLayer:
case BuiltInViewportIndex:
case BuiltInCullPrimitiveEXT:
case BuiltInPrimitiveShadingRateKHR:
if (mesh_shader)
expr = join("gl_MeshPrimitivesEXT[", to_expression(index, register_expression_read), "].", expr);
else
append_index(index, is_literal);
break;
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
default:
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
append_index(index, is_literal);
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
break;
}
}
HLSL: Fix-up some style issues from review.
2022-11-02 11:13:42 +00:00
else if (backend.force_merged_mesh_block && i == 0 && var &&
!is_builtin_variable(*var) && var->storage == StorageClassOutput)
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
{
HLSL: Fix-up some style issues from review.
2022-11-02 11:13:42 +00:00
if (is_per_primitive_variable(*var))
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
expr = join("gl_MeshPrimitivesEXT[", to_expression(index, register_expression_read), "].", expr);
else
expr = join("gl_MeshVerticesEXT[", to_expression(index, register_expression_read), "].", expr);
}
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
else if (options.flatten_multidimensional_arrays && dimension_flatten)
{
// If we are flattening multidimensional arrays, do manual stride computation.
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
auto &parent_type = get<SPIRType>(type->parent_type);
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
if (is_literal)
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
expr += convert_to_string(index);
else
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
expr += to_enclosed_expression(index, register_expression_read);
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
for (auto j = uint32_t(parent_type.array.size()); j; j--)
{
expr += " * ";
expr += enclose_expression(to_array_size(parent_type, j - 1));
}
if (parent_type.array.empty())
pending_array_enclose = false;
else
expr += " + ";
Fix tessellation control shaders from HLSL. Need to take into account that gl_Position[i] needs to be rewritten as gl_out[i].gl_Position instead.
2018-01-04 15:22:44 +00:00
if (!pending_array_enclose)
expr += "]";
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
}
MSL: Improve handling of sample masks.
2023-10-23 11:34:23 +00:00
else if (index_is_literal || !builtin_translates_to_nonarray(BuiltIn(get_decoration(base, DecorationBuiltIn))))
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
{
MSL: Improve handling of sample masks.
2023-10-23 11:34:23 +00:00
// Some builtins are arrays in SPIR-V but not in other languages, e.g. gl_SampleMask[] is an array in SPIR-V but not in Metal.
// By throwing away the index, we imply the index was 0, which it must be for gl_SampleMask.
// For literal indices we are working on composites, so we ignore this since we have already converted to proper array.
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
append_index(index, is_literal);
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
}
Consider plain Position builtin variable as well.
2023-07-03 12:15:26 +00:00
if (var && has_decoration(var->self, DecorationBuiltIn) &&
get_decoration(var->self, DecorationBuiltIn) == BuiltInPosition &&
get_execution_model() == ExecutionModelMeshEXT)
{
access_meshlet_position_y = true;
}
Fix issue #245: assignment of flattened input struct. Emit input struct assignment by assigning member by member from stage_in struct. Map qualified member name from pointer type, not base type. Add Comiler::expression_type_id() function, similar to expression_type().
2017-08-12 04:21:13 +00:00
type_id = type->parent_type;
type = &get<SPIRType>(type_id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Support std140 half matrices and arrays. Super awkward since there is no clean way to express this.
2023-11-27 12:36:49 +00:00
// If the physical type has an unnatural vecsize,
// we must assume it's a faked struct where the .data member
// is used for the real payload.
if (physical_type && (is_vector(*type) || is_scalar(*type)))
{
auto &phys = get<SPIRType>(physical_type);
if (phys.vecsize > 4)
expr += ".data";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
access_chain_is_arrayed = true;
}
MSL: Fix type redirection when struct members are reordered to align with offsets. Populate member_type_index_redirection as reverse lookup, not forward lookup. Move use of member_type_index_redirection from CompilerMSL::to_member_reference() to CompilerGLSL::access_chain_internal() to access all redirected type info, not just name.
2021-10-28 14:16:34 +00:00
// For structs, the index refers to a constant, which indexes into the members, possibly through a redirection mapping.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// We also check if this member is a builtin, since we then replace the entire expression with the builtin one.
else if (type->basetype == SPIRType::Struct)
{
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
if (!is_literal)
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
index = evaluate_constant_u32(index);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Fix type redirection when struct members are reordered to align with offsets. Populate member_type_index_redirection as reverse lookup, not forward lookup. Move use of member_type_index_redirection from CompilerMSL::to_member_reference() to CompilerGLSL::access_chain_internal() to access all redirected type info, not just name.
2021-10-28 14:16:34 +00:00
if (index < uint32_t(type->member_type_index_redirection.size()))
index = type->member_type_index_redirection[index];
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (index >= type->member_types.size())
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Member index is out of bounds!");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
HLSL: Add support to preserve (RW)StructuredBuffer resources.
2023-05-02 21:36:43 +00:00
if (hide_first_subscript)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
HLSL: Add support to preserve (RW)StructuredBuffer resources.
2023-05-02 21:36:43 +00:00
// First "._m0" subscript has been hidden, subsequent fields must be emitted even for structured buffers
hide_first_subscript = false;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
HLSL: Add support to preserve (RW)StructuredBuffer resources.
2023-05-02 21:36:43 +00:00
BuiltIn builtin = BuiltInMax;
if (is_member_builtin(*type, index, &builtin) && access_chain_needs_stage_io_builtin_translation(base))
{
if (access_chain_is_arrayed)
{
expr += ".";
expr += builtin_to_glsl(builtin, type->storage);
}
else
expr = builtin_to_glsl(builtin, type->storage);
track access to meshlet position.y, via SPIRExpression
2023-07-01 13:49:35 +00:00
if (builtin == BuiltInPosition && get_execution_model() == ExecutionModelMeshEXT)
{
access_meshlet_position_y = true;
}
HLSL: Add support to preserve (RW)StructuredBuffer resources.
2023-05-02 21:36:43 +00:00
}
CompilerMSL fix variables used in interface blocks aren't resolved correctly (#179).
2017-05-23 01:41:19 +00:00
else
MSL: Refactor member reference in terms of one boolean. ptr_chain was really just masking the proper i == 0 check. Be more explicit about what the check is actually doing and comment this.
2022-11-21 12:40:27 +00:00
{
HLSL: Add support to preserve (RW)StructuredBuffer resources.
2023-05-02 21:36:43 +00:00
// If the member has a qualified name, use it as the entire chain
string qual_mbr_name = get_member_qualified_name(type_id, index);
if (!qual_mbr_name.empty())
expr = qual_mbr_name;
else if (flatten_member_reference)
expr += join("_", to_member_name(*type, index));
else
{
// Any pointer de-refences for values are handled in the first access chain.
// For pointer chains, the pointer-ness is resolved through an array access.
// The only time this is not true is when accessing array of SSBO/UBO.
// This case is explicitly handled.
expr += to_member_reference(base, *type, index, ptr_chain || i != 0);
}
MSL: Refactor member reference in terms of one boolean. ptr_chain was really just masking the proper i == 0 check. Be more explicit about what the check is actually doing and comment this.
2022-11-21 12:40:27 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
if (has_member_decoration(type->self, index, DecorationInvariant))
is_invariant = true;
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
if (has_member_decoration(type->self, index, DecorationRelaxedPrecision))
relaxed_precision = true;
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
is_packed = member_is_packed_physical_type(*type, index);
Can deal with std140 matrices now. Refactor is coming together.
2019-07-19 09:21:02 +00:00
if (member_is_remapped_physical_type(*type, index))
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
physical_type = get_extended_member_decoration(type->self, index, SPIRVCrossDecorationPhysicalTypeID);
Refactor out packed expressions to extended decorations. Can't safely just cast to the original enum without lots of hacks.
2019-01-17 10:22:24 +00:00
else
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
physical_type = 0;
Refactor out packed expressions to extended decorations. Can't safely just cast to the original enum without lots of hacks.
2019-01-17 10:22:24 +00:00
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
row_major_matrix_needs_conversion = member_is_non_native_row_major_matrix(*type, index);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
type = &get<SPIRType>(type->member_types[index]);
}
// Matrix -> Vector
else if (type->columns > 1)
{
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
// If we have a row-major matrix here, we need to defer any transpose in case this access chain
// is used to store a column. We can resolve it right here and now if we access a scalar directly,
// by flipping indexing order of the matrix.
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
expr += "[";
HLSL: Implement stores for complex composites in ByteAddressBuffers.
2020-01-08 13:17:28 +00:00
if (is_literal)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
expr += convert_to_string(index);
else
MSL: Support more usecases for unpacked vectors. Additional usecases include array and vector indexing, variable declarations, loop initializers, function return values, switch statement evaluations, and various specialized MSL operations. Ultimately, we might consider refactoring CompilerMSL::to_expression() to always take into consideration possible unpacking behavior. Refactor CompilerGLSL::to_enclosed_unpacked_expression() for conciseness and consistency with similar functionality.
2021-10-21 20:11:33 +00:00
expr += to_unpacked_expression(index, register_expression_read);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
expr += "]";
MSL: Support std140 half matrices and arrays. Super awkward since there is no clean way to express this.
2023-11-27 12:36:49 +00:00
// If the physical type has an unnatural vecsize,
// we must assume it's a faked struct where the .data member
// is used for the real payload.
if (physical_type)
{
auto &phys = get<SPIRType>(physical_type);
if (phys.vecsize > 4 || phys.columns > 4)
expr += ".data";
}
Fix issue #245: assignment of flattened input struct. Emit input struct assignment by assigning member by member from stage_in struct. Map qualified member name from pointer type, not base type. Add Comiler::expression_type_id() function, similar to expression_type().
2017-08-12 04:21:13 +00:00
type_id = type->parent_type;
type = &get<SPIRType>(type_id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
// Vector -> Scalar
else if (type->vecsize > 1)
{
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
string deferred_index;
if (row_major_matrix_needs_conversion)
{
// Flip indexing order.
auto column_index = expr.find_last_of('[');
if (column_index != string::npos)
{
deferred_index = expr.substr(column_index);
MSL: Support std140 half matrices and arrays. Super awkward since there is no clean way to express this.
2023-11-27 12:36:49 +00:00
auto end_deferred_index = deferred_index.find_last_of(']');
if (end_deferred_index != string::npos && end_deferred_index + 1 != deferred_index.size())
{
// If we have any data member fixups, it must be transposed so that it refers to this index.
// E.g. [0].data followed by [1] would be shuffled to [1][0].data which is wrong,
// and needs to be [1].data[0] instead.
end_deferred_index++;
deferred_index = deferred_index.substr(end_deferred_index) +
deferred_index.substr(0, end_deferred_index);
}
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
expr.resize(column_index);
}
}
MSL: Workaround broken vector -> scalar access chain in MSL. On MSL, the compiler refuses to allow access chains into a normal vector type. What happens in practice instead is a read-modify-write where a vector type is loaded, modified and written back. The workaround is to convert a vector into a pointer-to-scalar before the access chain continues to add the scalar index.
2020-07-01 11:02:11 +00:00
// Internally, access chain implementation can also be used on composites,
// ignore scalar access workarounds in this case.
MSL: Do not consider effective storage for any composite.
2021-04-06 09:35:04 +00:00
StorageClass effective_storage = StorageClassGeneric;
MSL: Do not perform scalar fixups for control-point outputs.
2021-04-07 11:33:26 +00:00
bool ignore_potential_sliced_writes = false;
MSL: Do not consider effective storage for any composite.
2021-04-06 09:35:04 +00:00
if ((flags & ACCESS_CHAIN_FORCE_COMPOSITE_BIT) == 0)
{
MSL: Fix copy of arrays to/from stage IO variables. Need to take into account effective storage classes and whether or not we target stage IO blocks since native arrays are conditionally enabled.
2021-04-19 09:46:30 +00:00
if (expression_type(base).pointer)
MSL: Do not consider effective storage for any composite.
2021-04-06 09:35:04 +00:00
effective_storage = get_expression_effective_storage_class(base);
MSL: Do not perform scalar fixups for control-point outputs.
2021-04-07 11:33:26 +00:00
// Special consideration for control points.
// Control points can only be written by InvocationID, so there is no need
// to consider scalar access chains here.
// Cleans up some cases where it's very painful to determine the accurate storage class
// since blocks can be partially masked ...
MSL: Fix copy of arrays to/from stage IO variables. Need to take into account effective storage classes and whether or not we target stage IO blocks since native arrays are conditionally enabled.
2021-04-19 09:46:30 +00:00
auto *var = maybe_get_backing_variable(base);
MSL: Do not perform scalar fixups for control-point outputs.
2021-04-07 11:33:26 +00:00
if (var && var->storage == StorageClassOutput &&
get_execution_model() == ExecutionModelTessellationControl &&
!has_decoration(var->self, DecorationPatch))
{
ignore_potential_sliced_writes = true;
}
MSL: Do not consider effective storage for any composite.
2021-04-06 09:35:04 +00:00
}
MSL: Do not perform scalar fixups for control-point outputs.
2021-04-07 11:33:26 +00:00
else
ignore_potential_sliced_writes = true;
MSL: Workaround broken vector -> scalar access chain in MSL. On MSL, the compiler refuses to allow access chains into a normal vector type. What happens in practice instead is a read-modify-write where a vector type is loaded, modified and written back. The workaround is to convert a vector into a pointer-to-scalar before the access chain continues to add the scalar index.
2020-07-01 11:02:11 +00:00
MSL: Do not perform scalar fixups for control-point outputs.
2021-04-07 11:33:26 +00:00
if (!row_major_matrix_needs_conversion && !ignore_potential_sliced_writes)
MSL: Workaround broken vector -> scalar access chain in MSL. On MSL, the compiler refuses to allow access chains into a normal vector type. What happens in practice instead is a read-modify-write where a vector type is loaded, modified and written back. The workaround is to convert a vector into a pointer-to-scalar before the access chain continues to add the scalar index.
2020-07-01 11:02:11 +00:00
{
// On some backends, we might not be able to safely access individual scalars in a vector.
// To work around this, we might have to cast the access chain reference to something which can,
// like a pointer to scalar, which we can then index into.
prepare_access_chain_for_scalar_access(expr, get<SPIRType>(type->parent_type), effective_storage,
is_packed);
}
Clamp vector element access to vector size. In cases where we know the size of the vector and the index at compile time, we can check if it's accessing in bounds and rely in undefined behavior otherwise. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-11 15:57:57 +00:00
if (is_literal)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Clamp vector element access to vector size. In cases where we know the size of the vector and the index at compile time, we can check if it's accessing in bounds and rely in undefined behavior otherwise. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-11 15:57:57 +00:00
bool out_of_bounds = (index >= type->vecsize);
if (!is_packed && !row_major_matrix_needs_conversion)
{
expr += ".";
expr += index_to_swizzle(out_of_bounds ? 0 : index);
}
else
{
// For packed vectors, we can only access them as an array, not by swizzle.
expr += join("[", out_of_bounds ? 0 : index, "]");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
else if (ir.ids[index].get_type() == TypeConstant && !is_packed && !row_major_matrix_needs_conversion)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
auto &c = get<SPIRConstant>(index);
Clamp vector element access to vector size. In cases where we know the size of the vector and the index at compile time, we can check if it's accessing in bounds and rely in undefined behavior otherwise. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-11 15:57:57 +00:00
bool out_of_bounds = (c.scalar() >= type->vecsize);
Fix OpVectorExtractDynamic with spec constant op index. We cannot lower this to a swizzle, keep it dynamically indexed.
2019-10-17 09:11:23 +00:00
if (c.specialization)
{
// If the index is a spec constant, we cannot turn extract into a swizzle.
Clamp vector element access to vector size. In cases where we know the size of the vector and the index at compile time, we can check if it's accessing in bounds and rely in undefined behavior otherwise. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-11 15:57:57 +00:00
expr += join("[", out_of_bounds ? "0" : to_expression(index), "]");
Fix OpVectorExtractDynamic with spec constant op index. We cannot lower this to a swizzle, keep it dynamically indexed.
2019-10-17 09:11:23 +00:00
}
else
{
expr += ".";
Clamp vector element access to vector size. In cases where we know the size of the vector and the index at compile time, we can check if it's accessing in bounds and rely in undefined behavior otherwise. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-11 15:57:57 +00:00
expr += index_to_swizzle(out_of_bounds ? 0 : c.scalar());
Fix OpVectorExtractDynamic with spec constant op index. We cannot lower this to a swizzle, keep it dynamically indexed.
2019-10-17 09:11:23 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
expr += "[";
MSL: Support more usecases for unpacked vectors. Additional usecases include array and vector indexing, variable declarations, loop initializers, function return values, switch statement evaluations, and various specialized MSL operations. Ultimately, we might consider refactoring CompilerMSL::to_expression() to always take into consideration possible unpacking behavior. Refactor CompilerGLSL::to_enclosed_unpacked_expression() for conciseness and consistency with similar functionality.
2021-10-21 20:11:33 +00:00
expr += to_unpacked_expression(index, register_expression_read);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
expr += "]";
}
MSL: Do not perform scalar fixups for control-point outputs.
2021-04-07 11:33:26 +00:00
if (row_major_matrix_needs_conversion && !ignore_potential_sliced_writes)
MSL: Workaround broken vector -> scalar access chain in MSL. On MSL, the compiler refuses to allow access chains into a normal vector type. What happens in practice instead is a read-modify-write where a vector type is loaded, modified and written back. The workaround is to convert a vector into a pointer-to-scalar before the access chain continues to add the scalar index.
2020-07-01 11:02:11 +00:00
{
MSL: Support std140 half matrices and arrays. Super awkward since there is no clean way to express this.
2023-11-27 12:36:49 +00:00
if (prepare_access_chain_for_scalar_access(expr, get<SPIRType>(type->parent_type), effective_storage,
is_packed))
{
// We're in a pointer context now, so just remove any member dereference.
auto first_index = deferred_index.find_first_of('[');
if (first_index != string::npos && first_index != 0)
deferred_index = deferred_index.substr(first_index);
}
MSL: Workaround broken vector -> scalar access chain in MSL. On MSL, the compiler refuses to allow access chains into a normal vector type. What happens in practice instead is a read-modify-write where a vector type is loaded, modified and written back. The workaround is to convert a vector into a pointer-to-scalar before the access chain continues to add the scalar index.
2020-07-01 11:02:11 +00:00
}
track access to meshlet position.y, via SPIRExpression
2023-07-01 13:49:35 +00:00
if (access_meshlet_position_y)
{
if (is_literal)
{
Consider dynamically indexed gl_Position in mesh.
2023-07-03 12:15:42 +00:00
access_meshlet_position_y = index == 1;
track access to meshlet position.y, via SPIRExpression
2023-07-01 13:49:35 +00:00
}
else
{
Consider dynamically indexed gl_Position in mesh.
2023-07-03 12:15:42 +00:00
const auto *c = maybe_get<SPIRConstant>(index);
if (c)
access_meshlet_position_y = c->scalar() == 1;
else
{
// We don't know, but we have to assume no.
// Flip Y in mesh shaders is an opt-in horrible hack, so we'll have to assume shaders try to behave.
access_meshlet_position_y = false;
}
track access to meshlet position.y, via SPIRExpression
2023-07-01 13:49:35 +00:00
}
}
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
expr += deferred_index;
row_major_matrix_needs_conversion = false;
Access chain into packed vectors as arrays. Cleaner and should be more compatible with storing to packed vector elements. Fix CompositeExtract bug with packed vectors on MSL.
2018-03-13 11:13:01 +00:00
is_packed = false;
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
physical_type = 0;
Fix issue #245: assignment of flattened input struct. Emit input struct assignment by assigning member by member from stage_in struct. Map qualified member name from pointer type, not base type. Add Comiler::expression_type_id() function, similar to expression_type().
2017-08-12 04:21:13 +00:00
type_id = type->parent_type;
type = &get<SPIRType>(type_id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
else if (!backend.allow_truncated_access_chain)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Cannot subdivide a scalar value!");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
if (pending_array_enclose)
{
Add multidimensional array flattening test.
2017-05-22 15:40:00 +00:00
SPIRV_CROSS_THROW("Flattening of multidimensional arrays were enabled, "
"but the access chain was terminated in the middle of a multidimensional array. "
"This is not supported.");
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
}
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
if (meta)
{
meta->need_transpose = row_major_matrix_needs_conversion;
meta->storage_is_packed = is_packed;
meta->storage_is_invariant = is_invariant;
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
meta->storage_physical_type = physical_type;
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
meta->relaxed_precision = relaxed_precision;
track access to meshlet position.y, via SPIRExpression
2023-07-01 13:49:35 +00:00
meta->access_meshlet_position_y = access_meshlet_position_y;
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
}
CompilerMSL allow swizzle of packed_float3 vectors by unpacking to float3. Pass packed indicator back through OpAccessChain and OpLoad. Unpack packed vector before applying swizzle. Add packed swizzle test.
2018-01-05 22:46:56 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return expr;
Initial commit.
2016-03-02 17:09:16 +00:00
}
MSL: Fixes from review for SPV_KHR_physical_storage_buffer extension. - Assign ulongn physical type to buffer pointers in short arrays when array stride is larger than pointer size. - Support GL_EXT_buffer_reference_uvec2 casting buffer reference pointers to and from uvec2 values. - When packing structs, include structs inside physical buffers. - Update mechanism for traversing pointer arrays when calculating type sizes. - Added unit test shaders.
2022-07-01 20:10:41 +00:00
void CompilerGLSL::check_physical_type_cast(std::string &, const SPIRType *, uint32_t)
{
}
MSL: Support std140 half matrices and arrays. Super awkward since there is no clean way to express this.
2023-11-27 12:36:49 +00:00
bool CompilerGLSL::prepare_access_chain_for_scalar_access(std::string &, const SPIRType &, spv::StorageClass, bool &)
MSL: Workaround broken vector -> scalar access chain in MSL. On MSL, the compiler refuses to allow access chains into a normal vector type. What happens in practice instead is a read-modify-write where a vector type is loaded, modified and written back. The workaround is to convert a vector into a pointer-to-scalar before the access chain continues to add the scalar index.
2020-07-01 11:02:11 +00:00
{
MSL: Support std140 half matrices and arrays. Super awkward since there is no clean way to express this.
2023-11-27 12:36:49 +00:00
return false;
MSL: Workaround broken vector -> scalar access chain in MSL. On MSL, the compiler refuses to allow access chains into a normal vector type. What happens in practice instead is a read-modify-write where a vector type is loaded, modified and written back. The workaround is to convert a vector into a pointer-to-scalar before the access chain continues to add the scalar index.
2020-07-01 11:02:11 +00:00
}
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
string CompilerGLSL::to_flattened_struct_member(const string &basename, const SPIRType &type, uint32_t index)
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
{
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
auto ret = join(basename, "_", to_member_name(type, index));
ParsedIR::sanitize_underscores(ret);
return ret;
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
}
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
uint32_t CompilerGLSL::get_physical_type_stride(const SPIRType &) const
{
SPIRV_CROSS_THROW("Invalid to call get_physical_type_stride on a backend without native pointer support.");
}
Run style formatter.
2017-01-20 16:33:59 +00:00
string CompilerGLSL::access_chain(uint32_t base, const uint32_t *indices, uint32_t count, const SPIRType &target_type,
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
AccessChainMeta *meta, bool ptr_chain)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
Add tests for buffer block flattening
2017-01-16 22:19:49 +00:00
if (flattened_buffer_blocks.count(base))
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
uint32_t matrix_stride = 0;
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
uint32_t array_stride = 0;
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
bool need_transpose = false;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
flattened_access_chain_offset(expression_type(base), indices, count, 0, 16, &need_transpose, &matrix_stride,
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
&array_stride, ptr_chain);
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
if (meta)
{
meta->need_transpose = target_type.columns > 1 && need_transpose;
meta->storage_is_packed = false;
}
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Run format_all.sh.
2020-01-08 13:27:34 +00:00
return flattened_access_chain(base, indices, count, target_type, 0, matrix_stride, array_stride,
need_transpose);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
Fix cases for flattened struct write. Handle writing the entire struct as well as writing the elements individually.
2017-02-23 18:03:07 +00:00
else if (flattened_structs.count(base) && count > 0)
{
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
AccessChainFlags flags = ACCESS_CHAIN_CHAIN_ONLY_BIT | ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT;
if (ptr_chain)
flags |= ACCESS_CHAIN_PTR_CHAIN_BIT;
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
if (flattened_structs[base])
{
flags |= ACCESS_CHAIN_FLATTEN_ALL_MEMBERS_BIT;
if (meta)
meta->flattened_struct = target_type.basetype == SPIRType::Struct;
}
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
auto chain = access_chain_internal(base, indices, count, flags, nullptr).substr(1);
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
if (meta)
{
meta->need_transpose = false;
meta->storage_is_packed = false;
}
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
auto basename = to_flattened_access_chain_expression(base);
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
auto ret = join(basename, "_", chain);
ParsedIR::sanitize_underscores(ret);
return ret;
Fix cases for flattened struct write. Handle writing the entire struct as well as writing the elements individually.
2017-02-23 18:03:07 +00:00
}
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
else
{
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
AccessChainFlags flags = ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT;
if (ptr_chain)
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
{
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
flags |= ACCESS_CHAIN_PTR_CHAIN_BIT;
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
// PtrAccessChain could get complicated.
TypeID type_id = expression_type_id(base);
if (backend.native_pointers && has_decoration(type_id, DecorationArrayStride))
{
// If there is a mismatch we have to go via 64-bit pointer arithmetic :'(
// Using packed hacks only gets us so far, and is not designed to deal with pointer to
// random values. It works for structs though.
MSL: Cast to packed format when using unexpected stride. We're still technically missing handling for Aligned mask on Load/Store, but that needs separate analysis and gets horribly annoying ... This should cover most use cases.
2024-06-19 12:24:50 +00:00
auto &pointee_type = get_pointee_type(get<SPIRType>(type_id));
uint32_t physical_stride = get_physical_type_stride(pointee_type);
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
uint32_t requested_stride = get_decoration(type_id, DecorationArrayStride);
if (physical_stride != requested_stride)
MSL: Cast to packed format when using unexpected stride. We're still technically missing handling for Aligned mask on Load/Store, but that needs separate analysis and gets horribly annoying ... This should cover most use cases.
2024-06-19 12:24:50 +00:00
{
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
flags |= ACCESS_CHAIN_PTR_CHAIN_POINTER_ARITH_BIT;
MSL: Cast to packed format when using unexpected stride. We're still technically missing handling for Aligned mask on Load/Store, but that needs separate analysis and gets horribly annoying ... This should cover most use cases.
2024-06-19 12:24:50 +00:00
if (is_vector(pointee_type))
flags |= ACCESS_CHAIN_PTR_CHAIN_CAST_TO_SCALAR_BIT;
}
MSL: Consider pointer arithmetic for OpPtrAccessChain. If the stride is weird for non-struct types you gotta do what you gotta do.
2024-06-19 11:43:08 +00:00
}
}
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
return access_chain_internal(base, indices, count, flags, meta);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
}
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
string CompilerGLSL::load_flattened_struct(const string &basename, const SPIRType &type)
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
{
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
auto expr = type_to_glsl_constructor(type);
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
expr += '(';
for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++)
{
if (i)
expr += ", ";
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
auto &member_type = get<SPIRType>(type.member_types[i]);
if (member_type.basetype == SPIRType::Struct)
expr += load_flattened_struct(to_flattened_struct_member(basename, type, i), member_type);
else
expr += to_flattened_struct_member(basename, type, i);
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
}
expr += ')';
return expr;
}
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
std::string CompilerGLSL::to_flattened_access_chain_expression(uint32_t id)
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
{
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
// Do not use to_expression as that will unflatten access chains.
string basename;
if (const auto *var = maybe_get<SPIRVariable>(id))
basename = to_name(var->self);
else if (const auto *expr = maybe_get<SPIRExpression>(id))
basename = expr->expression;
else
basename = to_expression(id);
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
return basename;
}
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
void CompilerGLSL::store_flattened_struct(const string &basename, uint32_t rhs_id, const SPIRType &type,
const SmallVector<uint32_t> &indices)
{
SmallVector<uint32_t> sub_indices = indices;
sub_indices.push_back(0);
auto *member_type = &type;
for (auto &index : indices)
member_type = &get<SPIRType>(member_type->member_types[index]);
for (uint32_t i = 0; i < uint32_t(member_type->member_types.size()); i++)
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
{
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
sub_indices.back() = i;
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
auto lhs = join(basename, "_", to_member_name(*member_type, i));
ParsedIR::sanitize_underscores(lhs);
Fix cases for flattened struct write. Handle writing the entire struct as well as writing the elements individually.
2017-02-23 18:03:07 +00:00
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
if (get<SPIRType>(member_type->member_types[i]).basetype == SPIRType::Struct)
{
store_flattened_struct(lhs, rhs_id, type, sub_indices);
}
else
{
auto rhs = to_expression(rhs_id) + to_multi_member_reference(type, sub_indices);
statement(lhs, " = ", rhs, ";");
}
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
}
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
}
void CompilerGLSL::store_flattened_struct(uint32_t lhs_id, uint32_t value)
{
auto &type = expression_type(lhs_id);
auto basename = to_flattened_access_chain_expression(lhs_id);
store_flattened_struct(basename, value, type, {});
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
}
Run style formatter.
2017-01-20 16:33:59 +00:00
std::string CompilerGLSL::flattened_access_chain(uint32_t base, const uint32_t *indices, uint32_t count,
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride,
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
uint32_t /* array_stride */, bool need_transpose)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
if (!target_type.array.empty())
SPIRV_CROSS_THROW("Access chains that result in an array can not be flattened");
else if (target_type.basetype == SPIRType::Struct)
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
return flattened_access_chain_struct(base, indices, count, target_type, offset);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
else if (target_type.columns > 1)
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
return flattened_access_chain_matrix(base, indices, count, target_type, offset, matrix_stride, need_transpose);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
else
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
return flattened_access_chain_vector(base, indices, count, target_type, offset, matrix_stride, need_transpose);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
Run style formatter.
2017-01-20 16:33:59 +00:00
std::string CompilerGLSL::flattened_access_chain_struct(uint32_t base, const uint32_t *indices, uint32_t count,
const SPIRType &target_type, uint32_t offset)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
std::string expr;
HLSL: Make --flatten-ubo work correctly
2022-02-16 12:53:24 +00:00
if (backend.can_declare_struct_inline)
{
expr += type_to_glsl_constructor(target_type);
expr += "(";
}
else
expr += "{";
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Fix a few minor warnings. (i was used as a uint32_t in multiple places, like type_member_for_offset, so changed its type)
2017-03-07 08:59:26 +00:00
for (uint32_t i = 0; i < uint32_t(target_type.member_types.size()); ++i)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
if (i != 0)
Fix whitespace in generated flattened expressions Add whitespace after comma and around arithmetic operators.
2017-01-17 20:06:06 +00:00
expr += ", ";
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
const SPIRType &member_type = get<SPIRType>(target_type.member_types[i]);
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
uint32_t member_offset = type_struct_member_offset(target_type, i);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
// The access chain terminates at the struct, so we need to find matrix strides and row-major information
// ahead of time.
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
bool need_transpose = false;
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
bool relaxed = false;
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
uint32_t matrix_stride = 0;
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
if (member_type.columns > 1)
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
{
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
auto decorations = combined_decoration_for_member(target_type, i);
need_transpose = decorations.get(DecorationRowMajor);
relaxed = decorations.get(DecorationRelaxedPrecision);
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
matrix_stride = type_struct_member_matrix_stride(target_type, i);
}
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
auto tmp = flattened_access_chain(base, indices, count, member_type, offset + member_offset, matrix_stride,
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
0 /* array_stride */, need_transpose);
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
// Cannot forward transpositions, so resolve them here.
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
if (need_transpose)
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
expr += convert_row_major_matrix(tmp, member_type, 0, false, relaxed);
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
else
expr += tmp;
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
HLSL: Make --flatten-ubo work correctly
2022-02-16 12:53:24 +00:00
expr += backend.can_declare_struct_inline ? ")" : "}";
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
return expr;
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
Run style formatter.
2017-01-20 16:33:59 +00:00
std::string CompilerGLSL::flattened_access_chain_matrix(uint32_t base, const uint32_t *indices, uint32_t count,
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
const SPIRType &target_type, uint32_t offset,
uint32_t matrix_stride, bool need_transpose)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
assert(matrix_stride);
SPIRType tmp_type = target_type;
if (need_transpose)
swap(tmp_type.vecsize, tmp_type.columns);
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
std::string expr;
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
expr += type_to_glsl_constructor(tmp_type);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
expr += "(";
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
for (uint32_t i = 0; i < tmp_type.columns; i++)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
if (i != 0)
Fix whitespace in generated flattened expressions Add whitespace after comma and around arithmetic operators.
2017-01-17 20:06:06 +00:00
expr += ", ";
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
expr += flattened_access_chain_vector(base, indices, count, tmp_type, offset + i * matrix_stride, matrix_stride,
/* need_transpose= */ false);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
expr += ")";
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
return expr;
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
std::string CompilerGLSL::flattened_access_chain_vector(uint32_t base, const uint32_t *indices, uint32_t count,
const SPIRType &target_type, uint32_t offset,
uint32_t matrix_stride, bool need_transpose)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
Begin implementing ByteAddressBuffer flattening for HLSL.
2017-08-10 13:36:30 +00:00
auto result = flattened_access_chain_offset(expression_type(base), indices, count, offset, 16);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
auto buffer_name = to_name(expression_type(base).self);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
if (need_transpose)
{
std::string expr;
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Remove redundant constructor calls for scalar types
2017-01-24 16:09:58 +00:00
if (target_type.vecsize > 1)
{
expr += type_to_glsl_constructor(target_type);
expr += "(";
}
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
for (uint32_t i = 0; i < target_type.vecsize; ++i)
{
if (i != 0)
expr += ", ";
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
uint32_t component_offset = result.second + i * matrix_stride;
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
assert(component_offset % (target_type.width / 8) == 0);
uint32_t index = component_offset / (target_type.width / 8);
expr += buffer_name;
expr += "[";
expr += result.first; // this is a series of N1 * k1 + N2 * k2 + ... that is either empty or ends with a +
expr += convert_to_string(index / 4);
expr += "]";
expr += vector_swizzle(1, index % 4);
}
Remove redundant constructor calls for scalar types
2017-01-24 16:09:58 +00:00
if (target_type.vecsize > 1)
{
expr += ")";
}
Implement flattening of row major matrix indexing To extract a column from row-major matrix, we need to do a strided load one component at a time. In this case flattened_access_chain_offset still returns the offset to the first element, but the stride is equal to matrix stride instead of vector stride. For this to work, we need to pass matrix stride (and transpose flag) through, similar to how matrix flattening works. Additionally slightly clean up recursive flattened_access_chain structure - specifically, instead of deciding mid-traversal that we need matrix stride information, we can just pass the matrix stride through - for access chains that end in matrix/vector this gets us what we need, and for access chains that end in structs the flattened_access_chain_struct code will recompute correct stride/transposition data to pass through further.
2017-01-24 15:42:19 +00:00
return expr;
}
else
{
assert(result.second % (target_type.width / 8) == 0);
uint32_t index = result.second / (target_type.width / 8);
std::string expr;
expr += buffer_name;
expr += "[";
expr += result.first; // this is a series of N1 * k1 + N2 * k2 + ... that is either empty or ends with a +
expr += convert_to_string(index / 4);
expr += "]";
expr += vector_swizzle(target_type.vecsize, index % 4);
return expr;
}
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
std::pair<std::string, uint32_t> CompilerGLSL::flattened_access_chain_offset(
const SPIRType &basetype, const uint32_t *indices, uint32_t count, uint32_t offset, uint32_t word_stride,
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
bool *need_transpose, uint32_t *out_matrix_stride, uint32_t *out_array_stride, bool ptr_chain)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
Add traversal for active builtin variables. Refactor some ugly type-copying for access chains.
2017-03-06 14:21:00 +00:00
// Start traversing type hierarchy at the proper non-pointer types.
Rename get_non_pointer_type() methods. This better reflects their purpose now.
2019-01-08 18:54:40 +00:00
const auto *type = &get_pointee_type(basetype);
Add traversal for active builtin variables. Refactor some ugly type-copying for access chains.
2017-03-06 14:21:00 +00:00
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
std::string expr;
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
// Inherit matrix information in case we are access chaining a vector which might have come from a row major layout.
bool row_major_matrix_needs_conversion = need_transpose ? *need_transpose : false;
uint32_t matrix_stride = out_matrix_stride ? *out_matrix_stride : 0;
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
uint32_t array_stride = out_array_stride ? *out_array_stride : 0;
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
for (uint32_t i = 0; i < count; i++)
{
uint32_t index = indices[i];
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// Pointers
if (ptr_chain && i == 0)
{
// Here, the pointer type will be decorated with an array stride.
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
array_stride = get_decoration(basetype.self, DecorationArrayStride);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
if (!array_stride)
SPIRV_CROSS_THROW("SPIR-V does not define ArrayStride for buffer block.");
auto *constant = maybe_get<SPIRConstant>(index);
if (constant)
{
// Constant array access.
offset += constant->scalar() * array_stride;
}
else
{
// Dynamic array access.
if (array_stride % word_stride)
{
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Array stride for dynamic indexing must be divisible by the size "
"of a 4-component vector. "
"Likely culprit here is a float or vec2 array inside a push "
"constant block which is std430. "
"This cannot be flattened. Try using std140 layout instead.");
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
}
expr += to_enclosed_expression(index);
expr += " * ";
expr += convert_to_string(array_stride / word_stride);
expr += " + ";
}
}
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
// Arrays
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
else if (!type->array.empty())
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
Support int and uint as flattened UBO types.
2017-01-21 11:29:20 +00:00
auto *constant = maybe_get<SPIRConstant>(index);
if (constant)
{
// Constant array access.
offset += constant->scalar() * array_stride;
}
else
{
// Dynamic array access.
if (array_stride % word_stride)
{
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Array stride for dynamic indexing must be divisible by the size "
"of a 4-component vector. "
"Likely culprit here is a float or vec2 array inside a push "
"constant block which is std430. "
"This cannot be flattened. Try using std140 layout instead.");
Support int and uint as flattened UBO types.
2017-01-21 11:29:20 +00:00
}
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
expr += to_enclosed_expression(index, false);
Support int and uint as flattened UBO types.
2017-01-21 11:29:20 +00:00
expr += " * ";
expr += convert_to_string(array_stride / word_stride);
expr += " + ";
}
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Cleanups for flattened access chains.
2017-01-21 10:30:33 +00:00
uint32_t parent_type = type->parent_type;
type = &get<SPIRType>(parent_type);
Comment type ID a bit better.
2017-01-22 08:06:15 +00:00
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
if (!type->array.empty())
array_stride = get_decoration(parent_type, DecorationArrayStride);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
}
// For structs, the index refers to a constant, which indexes into the members.
// We also check if this member is a builtin, since we then replace the entire expression with the builtin one.
else if (type->basetype == SPIRType::Struct)
{
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
index = evaluate_constant_u32(index);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
if (index >= type->member_types.size())
SPIRV_CROSS_THROW("Member index is out of bounds!");
offset += type_struct_member_offset(*type, index);
Cleanups for flattened access chains.
2017-01-21 10:30:33 +00:00
auto &struct_type = *type;
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
type = &get<SPIRType>(type->member_types[index]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Cleanups for flattened access chains.
2017-01-21 10:30:33 +00:00
if (type->columns > 1)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Cleanups for flattened access chains.
2017-01-21 10:30:33 +00:00
matrix_stride = type_struct_member_matrix_stride(struct_type, index);
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
row_major_matrix_needs_conversion =
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
combined_decoration_for_member(struct_type, index).get(DecorationRowMajor);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
row_major_matrix_needs_conversion = false;
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
if (!type->array.empty())
array_stride = type_struct_member_array_stride(struct_type, index);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
// Matrix -> Vector
else if (type->columns > 1)
{
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
auto *constant = maybe_get<SPIRConstant>(index);
if (constant)
{
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
index = evaluate_constant_u32(index);
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
offset += index * (row_major_matrix_needs_conversion ? (type->width / 8) : matrix_stride);
}
else
{
uint32_t indexing_stride = row_major_matrix_needs_conversion ? (type->width / 8) : matrix_stride;
// Dynamic array access.
if (indexing_stride % word_stride)
{
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Matrix stride for dynamic indexing must be divisible by the size of a "
"4-component vector. "
"Likely culprit here is a row-major matrix being accessed dynamically. "
"This cannot be flattened. Try using std140 layout instead.");
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
}
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
expr += to_enclosed_expression(index, false);
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
expr += " * ";
expr += convert_to_string(indexing_stride / word_stride);
expr += " + ";
}
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
Cleanups for flattened access chains.
2017-01-21 10:30:33 +00:00
type = &get<SPIRType>(type->parent_type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
// Vector -> Scalar
else if (type->vecsize > 1)
{
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
auto *constant = maybe_get<SPIRConstant>(index);
if (constant)
{
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
index = evaluate_constant_u32(index);
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
offset += index * (row_major_matrix_needs_conversion ? matrix_stride : (type->width / 8));
}
else
{
uint32_t indexing_stride = row_major_matrix_needs_conversion ? matrix_stride : (type->width / 8);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
// Dynamic array access.
if (indexing_stride % word_stride)
{
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Stride for dynamic vector indexing must be divisible by the "
"size of a 4-component vector. "
"This cannot be flattened in legacy targets.");
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
}
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
expr += to_enclosed_expression(index, false);
Support loading col/row-major matrices from ByteAddressBuffer.
2017-10-26 14:35:18 +00:00
expr += " * ";
expr += convert_to_string(indexing_stride / word_stride);
expr += " + ";
}
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
Cleanups for flattened access chains.
2017-01-21 10:30:33 +00:00
type = &get<SPIRType>(type->parent_type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
SPIRV_CROSS_THROW("Cannot subdivide a scalar value!");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Implement access chain flattening support for row major matrices We currently only support access chains that end in a matrix by propagating "needs transpose" flag upstream which flips the matrix multiplication order. It's possible to support indexed extraction as well, however it would have to generate code like this: vec4 row = vec4(UBO[0].y, UBO[1].y, UBO[2].y, UBO[3].y); for a column equivalent of: vec4 row = UBO[1]; It is definitely possible to do so but it requires signaling the vector output that it needs to switch to per-component extraction which is a bit more trouble than this is worth for now.
2017-01-18 02:10:28 +00:00
if (need_transpose)
*need_transpose = row_major_matrix_needs_conversion;
Support int and uint as flattened UBO types.
2017-01-21 11:29:20 +00:00
if (out_matrix_stride)
*out_matrix_stride = matrix_stride;
HLSL: Support loading complex composites from ByteAddressBuffer.
2020-01-08 12:05:56 +00:00
if (out_array_stride)
*out_array_stride = array_stride;
Implement access chain flattening support for row major matrices We currently only support access chains that end in a matrix by propagating "needs transpose" flag upstream which flips the matrix multiplication order. It's possible to support indexed extraction as well, however it would have to generate code like this: vec4 row = vec4(UBO[0].y, UBO[1].y, UBO[2].y, UBO[3].y); for a column equivalent of: vec4 row = UBO[1]; It is definitely possible to do so but it requires signaling the vector output that it needs to switch to per-component extraction which is a bit more trouble than this is worth for now.
2017-01-18 02:10:28 +00:00
Refactor flattened_access_chain functions Instead of filling a std::string buffer passed by reference return a new string. This may be slightly slower in certain cases but they are pretty rare and this matches the code style better. Also streamline error handling in different branches and extract function to generate vector swizzle.
2017-01-18 02:07:56 +00:00
return std::make_pair(expr, offset);
Initial commit.
2016-03-02 17:09:16 +00:00
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
bool CompilerGLSL::should_dereference(uint32_t id)
{
const auto &type = expression_type(id);
// Non-pointer expressions don't need to be dereferenced.
if (!type.pointer)
return false;
// Handles shouldn't be dereferenced either.
if (!expression_is_lvalue(id))
return false;
// If id is a variable but not a phi variable, we should not dereference it.
if (auto *var = maybe_get<SPIRVariable>(id))
return var->phi_variable;
if (auto *expr = maybe_get<SPIRExpression>(id))
MSL: Don't dereference forwarded copies of `OpVariable` pointers. Fixes two more CTS tests under `dEQP-VK.spirv_assembly.instruction.compute.empty_struct.copying`.
2022-11-09 20:14:18 +00:00
{
// If id is an access chain, we should not dereference it.
if (expr->access_chain)
return false;
// If id is a forwarded copy of a variable pointer, we should not dereference it.
SPIRVariable *var = nullptr;
while (expr->loaded_from && expression_is_forwarded(expr->self))
{
auto &src_type = expression_type(expr->loaded_from);
// To be a copy, the pointer and its source expression must be the
// same type. Can't check type.self, because for some reason that's
// usually the base type with pointers stripped off. This check is
// complex enough that I've hoisted it out of the while condition.
Fixed typo in CompilerGLSL::should_dereference()
2023-01-03 19:19:42 +00:00
if (src_type.pointer != type.pointer || src_type.pointer_depth != type.pointer_depth ||
MSL: Don't dereference forwarded copies of `OpVariable` pointers. Fixes two more CTS tests under `dEQP-VK.spirv_assembly.instruction.compute.empty_struct.copying`.
2022-11-09 20:14:18 +00:00
src_type.parent_type != type.parent_type)
break;
if ((var = maybe_get<SPIRVariable>(expr->loaded_from)))
break;
if (!(expr = maybe_get<SPIRExpression>(expr->loaded_from)))
break;
}
return !var || var->phi_variable;
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// Otherwise, we should dereference this pointer expression.
return true;
}
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
bool CompilerGLSL::should_forward(uint32_t id) const
Initial commit.
2016-03-02 17:09:16 +00:00
{
Fix Options::force_temporary to work with OpenGL GLSL Setting force_temporary to true produces invalid GLSL because sampler variables are copied: highp sampler2D _377 = DiffuseMapTexture; This change fixes the problem by always forwarding forwardable variables. I also took an opportunity to restructure the code to make it easier to read and add extra conditions to in the future.
2018-10-30 17:45:41 +00:00
// If id is a variable we will try to forward it regardless of force_temporary check below
// This is important because otherwise we'll get local sampler copies (highp sampler2D foo = bar) that are invalid in OpenGL GLSL
Do not forward expressions which carry a huge amount of dependencies. Need to force temporaries eventually, or compilers have a tendency to explode.
2022-01-17 11:49:02 +00:00
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
auto *var = maybe_get<SPIRVariable>(id);
Remove forwardable bit in SPIRVariable. Was never really used for anything. It's always true.
2022-03-04 10:05:21 +00:00
if (var)
Consider Volatile in should_forward(). Never forward these variables.
2022-03-04 10:08:55 +00:00
{
Allow volatile vars that are not builtins to be forwarded. This fixes a regression introduced by 93b0dc7, where all volatile variables were not allowed to be forwarded. This doesn't work well for volatile memory object variables like images or buffer blocks, because it forces local variables to be defined, which is unnecessary, and sometimes results in wrong types. This patch restricts volatile builtin variables (eg. HelperInvocation) from being forwarded, but allows other volatile variables to be forwarded, as before.
2022-03-23 18:48:22 +00:00
// Never forward volatile builtin variables, e.g. SPIR-V 1.6 HelperInvocation.
return !(has_decoration(id, DecorationBuiltIn) && has_decoration(id, DecorationVolatile));
Consider Volatile in should_forward(). Never forward these variables.
2022-03-04 10:08:55 +00:00
}
Fix Options::force_temporary to work with OpenGL GLSL Setting force_temporary to true produces invalid GLSL because sampler variables are copied: highp sampler2D _377 = DiffuseMapTexture; This change fixes the problem by always forwarding forwardable variables. I also took an opportunity to restructure the code to make it easier to read and add extra conditions to in the future.
2018-10-30 17:45:41 +00:00
// For debugging emit temporary variables for all expressions
if (options.force_temporary)
return false;
Do not forward expressions which carry a huge amount of dependencies. Need to force temporaries eventually, or compilers have a tendency to explode.
2022-01-17 11:49:02 +00:00
// If an expression carries enough dependencies we need to stop forwarding at some point,
// or we explode compilers. There are usually limits to how much we can nest expressions.
auto *expr = maybe_get<SPIRExpression>(id);
const uint32_t max_expression_dependencies = 64;
if (expr && expr->expression_dependencies.size() >= max_expression_dependencies)
return false;
Allow volatile vars that are not builtins to be forwarded. This fixes a regression introduced by 93b0dc7, where all volatile variables were not allowed to be forwarded. This doesn't work well for volatile memory object variables like images or buffer blocks, because it forces local variables to be defined, which is unnecessary, and sometimes results in wrong types. This patch restricts volatile builtin variables (eg. HelperInvocation) from being forwarded, but allows other volatile variables to be forwarded, as before.
2022-03-23 18:48:22 +00:00
if (expr && expr->loaded_from
&& has_decoration(expr->loaded_from, DecorationBuiltIn)
&& has_decoration(expr->loaded_from, DecorationVolatile))
Consider Volatile in should_forward(). Never forward these variables.
2022-03-04 10:08:55 +00:00
{
Allow volatile vars that are not builtins to be forwarded. This fixes a regression introduced by 93b0dc7, where all volatile variables were not allowed to be forwarded. This doesn't work well for volatile memory object variables like images or buffer blocks, because it forces local variables to be defined, which is unnecessary, and sometimes results in wrong types. This patch restricts volatile builtin variables (eg. HelperInvocation) from being forwarded, but allows other volatile variables to be forwarded, as before.
2022-03-23 18:48:22 +00:00
// Never forward volatile builtin variables, e.g. SPIR-V 1.6 HelperInvocation.
Consider Volatile in should_forward(). Never forward these variables.
2022-03-04 10:08:55 +00:00
return false;
}
Fix Options::force_temporary to work with OpenGL GLSL Setting force_temporary to true produces invalid GLSL because sampler variables are copied: highp sampler2D _377 = DiffuseMapTexture; This change fixes the problem by always forwarding forwardable variables. I also took an opportunity to restructure the code to make it easier to read and add extra conditions to in the future.
2018-10-30 17:45:41 +00:00
// Immutable expression can always be forwarded.
if (is_immutable(id))
return true;
return false;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
bool CompilerGLSL::should_suppress_usage_tracking(uint32_t id) const
{
// Used only by opcodes which don't do any real "work", they just swizzle data in some fashion.
return !expression_is_forwarded(id) || expression_suppresses_usage_tracking(id);
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::track_expression_read(uint32_t id)
{
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
switch (ir.ids[id].get_type())
{
case TypeExpression:
{
auto &e = get<SPIRExpression>(id);
for (auto implied_read : e.implied_read_expressions)
track_expression_read(implied_read);
break;
}
case TypeAccessChain:
{
auto &e = get<SPIRAccessChain>(id);
for (auto implied_read : e.implied_read_expressions)
track_expression_read(implied_read);
break;
}
default:
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// If we try to read a forwarded temporary more than once we will stamp out possibly complex code twice.
// In this case, it's better to just bind the complex expression to the temporary and read that temporary twice.
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
if (expression_is_forwarded(id) && !expression_suppresses_usage_tracking(id))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
auto &v = expression_usage_counts[id];
v++;
Implement context-sensitive expression read tracking. When inside a loop, treat any read of outer expressions to happen multiple times, forcing a temporary of said outer expressions. This avoids the problem where we can end up relying on loop-invariant code motion to happen in the compiler when converting optimized shaders.
2020-06-29 10:20:35 +00:00
// If we create an expression outside a loop,
// but access it inside a loop, we're implicitly reading it multiple times.
// If the expression in question is expensive, we should hoist it out to avoid relying on loop-invariant code motion
// working inside the backend compiler.
if (expression_read_implies_multiple_reads(id))
v++;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (v >= 2)
{
//if (v == 2)
// fprintf(stderr, "ID %u was forced to temporary due to more than 1 expression use!\n", id);
// Force a recompile after this pass to avoid forwarding this variable.
Add more scenarios where we can guarantee forward progress. The patterns where we force temporary due to invalid/overused expression -> recompile should be seen as making forward progress, and there are very rare scenarios where these recompiles can cascade into many loops. Refactor this style of logic into a new function which is equivalent to handle_invalid_expression().
2022-02-16 11:12:58 +00:00
force_temporary_and_recompile(id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
bool CompilerGLSL::args_will_forward(uint32_t id, const uint32_t *args, uint32_t num_args, bool pure)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (forced_temporaries.find(id) != end(forced_temporaries))
return false;
for (uint32_t i = 0; i < num_args; i++)
if (!should_forward(args[i]))
return false;
// We need to forward globals as well.
if (!pure)
{
for (auto global : global_variables)
if (!should_forward(global))
return false;
for (auto aliased : aliased_variables)
if (!should_forward(aliased))
return false;
}
return true;
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::register_impure_function_call()
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Impure functions can modify globals and aliased variables, so invalidate them as well.
for (auto global : global_variables)
flush_dependees(get<SPIRVariable>(global));
for (auto aliased : aliased_variables)
flush_dependees(get<SPIRVariable>(aliased));
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::register_call_out_argument(uint32_t id)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
register_write(id);
Initial commit.
2016-03-02 17:09:16 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto *var = maybe_get<SPIRVariable>(id);
if (var)
flush_variable_declaration(var->self);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Do not emit storage qualifiers for local variables. Metal backend uses local variables to implement global variables. Do not emit storage qualifiers for any variable which is declared inside a function.
2017-02-24 10:15:34 +00:00
string CompilerGLSL::variable_decl_function_local(SPIRVariable &var)
{
// These variables are always function local,
// so make sure we emit the variable without storage qualifiers.
// Some backends will inject custom variables locally in a function
// with a storage qualifier which is not function-local.
auto old_storage = var.storage;
var.storage = StorageClassFunction;
auto expr = variable_decl(var);
var.storage = old_storage;
return expr;
}
Fix declaration of loop variables with a Phi helper copy. Certain Phi variables need to maintain a temporary copy, but we forgot to declare them when the master variable is a loop variable itself.
2019-06-25 08:45:15 +00:00
void CompilerGLSL::emit_variable_temporary_copies(const SPIRVariable &var)
{
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Ensure that we declare phi-variable copies even if the original declaration isn't deferred
GLSL: Minor nit, check flushed_phi_variables with count().
2019-10-24 15:12:23 +00:00
if (var.allocate_temporary_copy && !flushed_phi_variables.count(var.self))
Fix declaration of loop variables with a Phi helper copy. Certain Phi variables need to maintain a temporary copy, but we forgot to declare them when the master variable is a loop variable itself.
2019-06-25 08:45:15 +00:00
{
auto &type = get<SPIRType>(var.basetype);
auto &flags = get_decoration_bitset(var.self);
statement(flags_to_qualifiers_glsl(type, flags), variable_decl(type, join("_", var.self, "_copy")), ";");
There are occasions where phi-variable copies are introduced for original variables which are fully declared, which coud result in the phi-variable never being declared and the shader not compiling, so declare the phi-variables when this happens. Change made in two parts. 1. Ensure that we declare phi-variable copies even if the original declaration isn't deferred. 2. Only flush phi variables once, avoids duplicate definitions.
2019-08-14 15:04:58 +00:00
flushed_phi_variables.insert(var.self);
Fix declaration of loop variables with a Phi helper copy. Certain Phi variables need to maintain a temporary copy, but we forgot to declare them when the master variable is a loop variable itself.
2019-06-25 08:45:15 +00:00
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::flush_variable_declaration(uint32_t id)
{
Rearranged all 'UE Change' comments to match to project's coding style.
2019-09-18 18:03:54 +00:00
// Ensure that we declare phi-variable copies even if the original declaration isn't deferred
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto *var = maybe_get<SPIRVariable>(id);
if (var && var->deferred_declaration)
{
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
string initializer;
if (options.force_zero_initialized_variables &&
(var->storage == StorageClassFunction || var->storage == StorageClassGeneric ||
var->storage == StorageClassPrivate) &&
!var->initializer && type_can_zero_initialize(get_variable_data_type(*var)))
{
initializer = join(" = ", to_zero_initialized_expression(get_variable_data_type_id(*var)));
}
statement(variable_decl_function_local(*var), initializer, ";");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
var->deferred_declaration = false;
}
There are occasions where phi-variable copies are introduced for original variables which are fully declared, which coud result in the phi-variable never being declared and the shader not compiling, so declare the phi-variables when this happens. Change made in two parts. 1. Ensure that we declare phi-variable copies even if the original declaration isn't deferred. 2. Only flush phi variables once, avoids duplicate definitions.
2019-08-14 15:04:58 +00:00
if (var)
{
emit_variable_temporary_copies(*var);
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
bool CompilerGLSL::remove_duplicate_swizzle(string &op)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto pos = op.find_last_of('.');
if (pos == string::npos || pos == 0)
return false;
string final_swiz = op.substr(pos + 1, string::npos);
if (backend.swizzle_is_function)
{
if (final_swiz.size() < 2)
return false;
if (final_swiz.substr(final_swiz.size() - 2, string::npos) == "()")
final_swiz.erase(final_swiz.size() - 2, string::npos);
else
return false;
}
// Check if final swizzle is of form .x, .xy, .xyz, .xyzw or similar.
// If so, and previous swizzle is of same length,
// we can drop the final swizzle altogether.
for (uint32_t i = 0; i < final_swiz.size(); i++)
{
static const char expected[] = { 'x', 'y', 'z', 'w' };
if (i >= 4 || final_swiz[i] != expected[i])
return false;
}
auto prevpos = op.find_last_of('.', pos - 1);
if (prevpos == string::npos)
return false;
prevpos++;
// Make sure there are only swizzles here ...
for (auto i = prevpos; i < pos; i++)
{
if (op[i] < 'w' || op[i] > 'z')
{
// If swizzles are foo.xyz() like in C++ backend for example, check for that.
if (backend.swizzle_is_function && i + 2 == pos && op[i] == '(' && op[i + 1] == ')')
break;
return false;
}
}
// If original swizzle is large enough, just carve out the components we need.
// E.g. foobar.wyx.xy will turn into foobar.wy.
if (pos - prevpos >= final_swiz.size())
{
op.erase(prevpos + final_swiz.size(), string::npos);
// Add back the function call ...
if (backend.swizzle_is_function)
op += "()";
}
return true;
Initial commit.
2016-03-02 17:09:16 +00:00
}
// Optimizes away vector swizzles where we have something like
// vec3 foo;
// foo.xyz <-- swizzle expression does nothing.
// This is a very common pattern after OpCompositeCombine.
bool CompilerGLSL::remove_unity_swizzle(uint32_t base, string &op)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto pos = op.find_last_of('.');
if (pos == string::npos || pos == 0)
return false;
string final_swiz = op.substr(pos + 1, string::npos);
if (backend.swizzle_is_function)
{
if (final_swiz.size() < 2)
return false;
if (final_swiz.substr(final_swiz.size() - 2, string::npos) == "()")
final_swiz.erase(final_swiz.size() - 2, string::npos);
else
return false;
}
// Check if final swizzle is of form .x, .xy, .xyz, .xyzw or similar.
// If so, and previous swizzle is of same length,
// we can drop the final swizzle altogether.
for (uint32_t i = 0; i < final_swiz.size(); i++)
{
static const char expected[] = { 'x', 'y', 'z', 'w' };
if (i >= 4 || final_swiz[i] != expected[i])
return false;
}
auto &type = expression_type(base);
// Sanity checking ...
Updates for pull request #1162
2019-09-23 22:05:04 +00:00
assert(type.columns == 1 && type.array.empty());
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (type.vecsize == final_swiz.size())
op.erase(pos, string::npos);
return true;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Do not merge swizzles for anything other than vectors.
2018-01-22 08:52:57 +00:00
string CompilerGLSL::build_composite_combiner(uint32_t return_type, const uint32_t *elems, uint32_t length)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
ID base = 0;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string op;
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
string subop;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Do not merge swizzles for anything other than vectors.
2018-01-22 08:52:57 +00:00
// Can only merge swizzles for vectors.
auto &type = get<SPIRType>(return_type);
bool can_apply_swizzle_opt = type.basetype != SPIRType::Struct && type.array.empty() && type.columns == 1;
bool swizzle_optimization = false;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (uint32_t i = 0; i < length; i++)
{
auto *e = maybe_get<SPIRExpression>(elems[i]);
// If we're merging another scalar which belongs to the same base
// object, just merge the swizzles to avoid triggering more than 1 expression read as much as possible!
Do not merge swizzles for anything other than vectors.
2018-01-22 08:52:57 +00:00
if (can_apply_swizzle_opt && e && e->base_expression && e->base_expression == base)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
// Only supposed to be used for vector swizzle -> scalar.
assert(!e->expression.empty() && e->expression.front() == '.');
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
subop += e->expression.substr(1, string::npos);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
swizzle_optimization = true;
}
else
{
// We'll likely end up with duplicated swizzles, e.g.
// foobar.xyz.xyz from patterns like
CompilerMSL allow swizzle of packed_float3 vectors by unpacking to float3. Pass packed indicator back through OpAccessChain and OpLoad. Unpack packed vector before applying swizzle. Add packed swizzle test.
2018-01-05 22:46:56 +00:00
// OpVectorShuffle
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// OpCompositeExtract x 3
// OpCompositeConstruct 3x + other scalar.
// Just modify op in-place.
if (swizzle_optimization)
{
if (backend.swizzle_is_function)
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
subop += "()";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Don't attempt to remove unity swizzling if we managed to remove duplicate swizzles.
// The base "foo" might be vec4, while foo.xyz is vec3 (OpVectorShuffle) and looks like a vec3 due to the .xyz tacked on.
// We only want to remove the swizzles if we're certain that the resulting base will be the same vecsize.
// Essentially, we can only remove one set of swizzles, since that's what we have control over ...
// Case 1:
// foo.yxz.xyz: Duplicate swizzle kicks in, giving foo.yxz, we are done.
// foo.yxz was the result of OpVectorShuffle and we don't know the type of foo.
// Case 2:
// foo.xyz: Duplicate swizzle won't kick in.
// If foo is vec3, we can remove xyz, giving just foo.
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
if (!remove_duplicate_swizzle(subop))
remove_unity_swizzle(base, subop);
// Strips away redundant parens if we created them during component extraction.
strip_enclosed_expression(subop);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
swizzle_optimization = false;
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
op += subop;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
else
op += subop;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (i)
op += ", ";
MSL: Improve handling of array types in buffer objects. When loading and storing array types which belong to buffer objects, we need to treat these values as not being value types. Also, need to handle array load/store from/to more address space combinations.
2020-06-18 09:37:24 +00:00
Run format_all.sh.
2020-07-01 09:42:58 +00:00
bool uses_buffer_offset =
type.basetype == SPIRType::Struct && has_member_decoration(type.self, i, DecorationOffset);
MSL: Consider bool/short remapping when dealing with composites.
2023-06-06 11:18:51 +00:00
subop = to_composite_constructor_expression(type, elems[i], uses_buffer_offset);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
base = e ? e->base_expression : ID(0);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
if (swizzle_optimization)
{
if (backend.swizzle_is_function)
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
subop += "()";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
if (!remove_duplicate_swizzle(subop))
remove_unity_swizzle(base, subop);
// Strips away redundant parens if we created them during component extraction.
strip_enclosed_expression(subop);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
op += subop;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return op;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
bool CompilerGLSL::skip_argument(uint32_t id) const
{
if (!combined_image_samplers.empty() || !options.vulkan_semantics)
{
auto &type = expression_type(id);
if (type.basetype == SPIRType::Sampler || (type.basetype == SPIRType::Image && type.image.sampled == 1))
return true;
}
return false;
}
Do not use RMW rewrite for matrices. Does not work on MSL.
2018-05-04 08:35:32 +00:00
bool CompilerGLSL::optimize_read_modify_write(const SPIRType &type, const string &lhs, const string &rhs)
Optimize for read-modify-writes. Required for legacy loop increments.
2016-12-16 12:14:22 +00:00
{
// Do this with strings because we have a very clear pattern we can check for and it avoids
// adding lots of special cases to the code emission.
Optimize += 1, -= 1 to ++, --. Purely cosmetic, but easier to read.
2016-12-16 12:24:49 +00:00
if (rhs.size() < lhs.size() + 3)
return false;
Do not use RMW rewrite for matrices. Does not work on MSL.
2018-05-04 08:35:32 +00:00
// Do not optimize matrices. They are a bit awkward to reason about in general
// (in which order does operation happen?), and it does not work on MSL anyways.
if (type.vecsize > 1 && type.columns > 1)
return false;
Optimize for read-modify-writes. Required for legacy loop increments.
2016-12-16 12:14:22 +00:00
auto index = rhs.find(lhs);
if (index != 0)
return false;
// TODO: Shift operators, but it's not important for now.
auto op = rhs.find_first_of("+-/*%|&^", lhs.size() + 1);
if (op != lhs.size() + 1)
return false;
Fix assignment optimization for logical and/or. "x = x && y" was converted to "x &= y", which is invalid.
2017-09-05 15:05:53 +00:00
// Check that the op is followed by space. This excludes && and ||.
Run format_all.sh.
2017-09-06 07:15:27 +00:00
if (rhs[op + 1] != ' ')
Fix assignment optimization for logical and/or. "x = x && y" was converted to "x &= y", which is invalid.
2017-09-05 15:05:53 +00:00
return false;
Optimize += 1, -= 1 to ++, --. Purely cosmetic, but easier to read.
2016-12-16 12:24:49 +00:00
char bop = rhs[op];
auto expr = rhs.substr(lhs.size() + 3);
GLSL: Fix expression reorder bug with legacy FMA fallback.
2023-03-30 14:51:05 +00:00
// Avoids false positives where we get a = a * b + c.
// Normally, these expressions are always enclosed, but unexpected code paths may end up hitting this.
if (needs_enclose_expression(expr))
return false;
Optimize += 1, -= 1 to ++, --. Purely cosmetic, but easier to read.
2016-12-16 12:24:49 +00:00
// Try to find increments and decrements. Makes it look neater as += 1, -= 1 is fairly rare to see in real code.
// Find some common patterns which are equivalent.
if ((bop == '+' || bop == '-') && (expr == "1" || expr == "uint(1)" || expr == "1u" || expr == "int(1u)"))
statement(lhs, bop, bop, ";");
else
statement(lhs, " ", bop, "= ", expr, ";");
Optimize for read-modify-writes. Required for legacy loop increments.
2016-12-16 12:14:22 +00:00
return true;
}
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
void CompilerGLSL::register_control_dependent_expression(uint32_t expr)
{
if (forwarded_temporaries.find(expr) == end(forwarded_temporaries))
return;
assert(current_emitting_block);
current_emitting_block->invalidate_expressions.push_back(expr);
}
void CompilerGLSL::emit_block_instructions(SPIRBlock &block)
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
{
current_emitting_block = &block;
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
if (backend.requires_relaxed_precision_analysis)
{
// If PHI variables are consumed in unexpected precision contexts, copy them here.
GLSL: Fix bug with mixed precision on PHI variables.
2023-06-07 12:49:42 +00:00
for (size_t i = 0, n = block.phi_variables.size(); i < n; i++)
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
{
GLSL: Fix bug with mixed precision on PHI variables.
2023-06-07 12:49:42 +00:00
auto &phi = block.phi_variables[i];
// Ensure we only copy once. We know a-priori that this array will lay out
// the same function variables together.
if (i && block.phi_variables[i - 1].function_variable == phi.function_variable)
continue;
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
auto itr = temporary_to_mirror_precision_alias.find(phi.function_variable);
if (itr != temporary_to_mirror_precision_alias.end())
{
// Explicitly, we don't want to inherit RelaxedPrecision state in this CopyObject,
// so it helps to have handle_instruction_precision() on the outside of emit_instruction().
EmbeddedInstruction inst;
inst.op = OpCopyObject;
inst.length = 3;
inst.ops.push_back(expression_type_id(itr->first));
inst.ops.push_back(itr->second);
inst.ops.push_back(itr->first);
emit_instruction(inst);
}
}
}
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
for (auto &op : block.ops)
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
{
auto temporary_copy = handle_instruction_precision(op);
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
emit_instruction(op);
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
if (temporary_copy.dst_id)
{
// Explicitly, we don't want to inherit RelaxedPrecision state in this CopyObject,
// so it helps to have handle_instruction_precision() on the outside of emit_instruction().
EmbeddedInstruction inst;
inst.op = OpCopyObject;
inst.length = 3;
inst.ops.push_back(expression_type_id(temporary_copy.src_id));
inst.ops.push_back(temporary_copy.dst_id);
inst.ops.push_back(temporary_copy.src_id);
// Never attempt to hoist mirrored temporaries.
// They are hoisted in lock-step with their parents.
block_temporary_hoisting = true;
emit_instruction(inst);
block_temporary_hoisting = false;
}
}
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
current_emitting_block = nullptr;
}
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
void CompilerGLSL::disallow_forwarding_in_expression_chain(const SPIRExpression &expr)
{
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
// Allow trivially forwarded expressions like OpLoad or trivial shuffles,
// these will be marked as having suppressed usage tracking.
// Our only concern is to make sure arithmetic operations are done in similar ways.
Fix severe performance issue with invariant expression invalidation. We were going down a tree of expressions multiple times and this caused an exponential explosion in time, which was not caught until recently. Fix this by blocking any traversal going through an ID more than one time. This fix overall improves performance by almost an order of magnitude on a particular test shader rather than slowing it down by ~75x.
2019-08-01 07:51:44 +00:00
if (expression_is_forwarded(expr.self) && !expression_suppresses_usage_tracking(expr.self) &&
forced_invariant_temporaries.count(expr.self) == 0)
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
{
Add more scenarios where we can guarantee forward progress. The patterns where we force temporary due to invalid/overused expression -> recompile should be seen as making forward progress, and there are very rare scenarios where these recompiles can cascade into many loops. Refactor this style of logic into a new function which is equivalent to handle_invalid_expression().
2022-02-16 11:12:58 +00:00
force_temporary_and_recompile(expr.self);
Fix severe performance issue with invariant expression invalidation. We were going down a tree of expressions multiple times and this caused an exponential explosion in time, which was not caught until recently. Fix this by blocking any traversal going through an ID more than one time. This fix overall improves performance by almost an order of magnitude on a particular test shader rather than slowing it down by ~75x.
2019-08-01 07:51:44 +00:00
forced_invariant_temporaries.insert(expr.self);
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
Fix severe performance issue with invariant expression invalidation. We were going down a tree of expressions multiple times and this caused an exponential explosion in time, which was not caught until recently. Fix this by blocking any traversal going through an ID more than one time. This fix overall improves performance by almost an order of magnitude on a particular test shader rather than slowing it down by ~75x.
2019-08-01 07:51:44 +00:00
for (auto &dependent : expr.expression_dependencies)
disallow_forwarding_in_expression_chain(get<SPIRExpression>(dependent));
}
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
}
void CompilerGLSL::handle_store_to_invariant_variable(uint32_t store_id, uint32_t value_id)
{
// Variables or access chains marked invariant are complicated. We will need to make sure the code-gen leading up to
// this variable is consistent. The failure case for SPIRV-Cross is when an expression is forced to a temporary
// in one translation unit, but not another, e.g. due to multiple use of an expression.
// This causes variance despite the output variable being marked invariant, so the solution here is to force all dependent
// expressions to be temporaries.
// It is uncertain if this is enough to support invariant in all possible cases, but it should be good enough
// for all reasonable uses of invariant.
if (!has_decoration(store_id, DecorationInvariant))
return;
auto *expr = maybe_get<SPIRExpression>(value_id);
if (!expr)
return;
disallow_forwarding_in_expression_chain(*expr);
}
Avoid unintentional name conflict with HLSL backend.
2019-01-17 11:21:16 +00:00
void CompilerGLSL::emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression)
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
{
auto rhs = to_pointer_expression(rhs_expression);
// Statements to OpStore may be empty if it is a struct with zero members. Just forward the store to /dev/null.
if (!rhs.empty())
{
handle_store_to_invariant_variable(lhs_expression, rhs_expression);
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
if (!unroll_array_to_complex_store(lhs_expression, rhs_expression))
{
auto lhs = to_dereferenced_expression(lhs_expression);
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
if (has_decoration(lhs_expression, DecorationNonUniform))
convert_non_uniform_expression(lhs, lhs_expression);
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
// We might need to cast in order to store to a builtin.
MSL: Workaround compiler crashes when using threadgroup bool. Promote to short instead and do simple casts on load/store instead. Not 100% complete fix since structs can contain booleans, but this is getting into pretty ridiculously complicated territory.
2021-10-25 08:55:11 +00:00
cast_to_variable_store(lhs_expression, rhs, expression_type(rhs_expression));
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
// Tries to optimize assignments like "<lhs> = <lhs> op expr".
// While this is purely cosmetic, this is important for legacy ESSL where loop
// variable increments must be in either i++ or i += const-expr.
// Without this, we end up with i = i + 1, which is correct GLSL, but not correct GLES 2.0.
if (!optimize_read_modify_write(expression_type(rhs_expression), lhs, rhs))
statement(lhs, " = ", rhs, ";");
}
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
register_write(lhs_expression);
}
}
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
uint32_t CompilerGLSL::get_integer_width_for_instruction(const Instruction &instr) const
{
if (instr.length < 3)
return 32;
auto *ops = stream(instr);
switch (instr.op)
{
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
case OpSConvert:
case OpConvertSToF:
case OpUConvert:
case OpConvertUToF:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
case OpIEqual:
case OpINotEqual:
case OpSLessThan:
case OpSLessThanEqual:
case OpSGreaterThan:
case OpSGreaterThanEqual:
HLSL: Fix unrolled S/G LE/LT/GE/GT opcodes. Need to bitcast the unrolled expressions as well.
2019-10-14 14:08:39 +00:00
case OpULessThan:
case OpULessThanEqual:
case OpUGreaterThan:
case OpUGreaterThanEqual:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
return expression_type(ops[2]).width;
MSL: Fix SUMulExtended for 64-bit inputs.
2024-04-15 11:37:00 +00:00
case OpSMulExtended:
case OpUMulExtended:
return get<SPIRType>(get<SPIRType>(ops[0]).member_types[0]).width;
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
default:
{
// We can look at result type which is more robust.
auto *type = maybe_get<SPIRType>(ops[0]);
if (type && type_is_integral(*type))
return type->width;
else
return 32;
}
}
}
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
uint32_t CompilerGLSL::get_integer_width_for_glsl_instruction(GLSLstd450 op, const uint32_t *ops, uint32_t length) const
{
if (length < 1)
return 32;
switch (op)
{
case GLSLstd450SAbs:
case GLSLstd450SSign:
case GLSLstd450UMin:
case GLSLstd450SMin:
case GLSLstd450UMax:
case GLSLstd450SMax:
case GLSLstd450UClamp:
case GLSLstd450SClamp:
case GLSLstd450FindSMsb:
case GLSLstd450FindUMsb:
return expression_type(ops[0]).width;
default:
{
// We don't need to care about other opcodes, just return 32.
return 32;
}
}
}
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
void CompilerGLSL::forward_relaxed_precision(uint32_t dst_id, const uint32_t *args, uint32_t length)
{
// Only GLSL supports RelaxedPrecision directly.
// We cannot implement this in HLSL or MSL because it is tied to the type system.
// In SPIR-V, everything must masquerade as 32-bit.
if (!backend.requires_relaxed_precision_analysis)
return;
auto input_precision = analyze_expression_precision(args, length);
// For expressions which are loaded or directly forwarded, we inherit mediump implicitly.
// For dst_id to be analyzed properly, it must inherit any relaxed precision decoration from src_id.
if (input_precision == Options::Mediump)
set_decoration(dst_id, DecorationRelaxedPrecision);
}
CompilerGLSL::Options::Precision CompilerGLSL::analyze_expression_precision(const uint32_t *args, uint32_t length) const
{
// Now, analyze the precision at which the arguments would run.
// GLSL rules are such that the precision used to evaluate an expression is equal to the highest precision
// for the inputs. Constants do not have inherent precision and do not contribute to this decision.
// If all inputs are constants, they inherit precision from outer expressions, including an l-value.
// In this case, we'll have to force a temporary for dst_id so that we can bind the constant expression with
// correct precision.
bool expression_has_highp = false;
bool expression_has_mediump = false;
for (uint32_t i = 0; i < length; i++)
{
uint32_t arg = args[i];
GLSL: Do not analyze precision for Undef variables. Undefs won't have a chance to emit aliases, and any expression depending on Undef will be garbage either way.
2022-05-13 10:14:56 +00:00
auto handle_type = ir.ids[arg].get_type();
if (handle_type == TypeConstant || handle_type == TypeConstantOp || handle_type == TypeUndef)
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
continue;
if (has_decoration(arg, DecorationRelaxedPrecision))
expression_has_mediump = true;
else
expression_has_highp = true;
}
if (expression_has_highp)
return Options::Highp;
else if (expression_has_mediump)
return Options::Mediump;
else
return Options::DontCare;
}
void CompilerGLSL::analyze_precision_requirements(uint32_t type_id, uint32_t dst_id, uint32_t *args, uint32_t length)
{
if (!backend.requires_relaxed_precision_analysis)
return;
auto &type = get<SPIRType>(type_id);
// RelaxedPrecision only applies to 32-bit values.
if (type.basetype != SPIRType::Float && type.basetype != SPIRType::Int && type.basetype != SPIRType::UInt)
return;
bool operation_is_highp = !has_decoration(dst_id, DecorationRelaxedPrecision);
auto input_precision = analyze_expression_precision(args, length);
if (input_precision == Options::DontCare)
{
consume_temporary_in_precision_context(type_id, dst_id, input_precision);
return;
}
// In SPIR-V and GLSL, the semantics are flipped for how relaxed precision is determined.
// In SPIR-V, the operation itself marks RelaxedPrecision, meaning that inputs can be truncated to 16-bit.
// However, if the expression is not, inputs must be expanded to 32-bit first,
// since the operation must run at high precision.
// This is the awkward part, because if we have mediump inputs, or expressions which derived from mediump,
// we might have to forcefully bind the source IDs to highp temporaries. This is done by clearing decorations
// and forcing temporaries. Similarly for mediump operations. We bind highp expressions to mediump variables.
if ((operation_is_highp && input_precision == Options::Mediump) ||
(!operation_is_highp && input_precision == Options::Highp))
{
auto precision = operation_is_highp ? Options::Highp : Options::Mediump;
for (uint32_t i = 0; i < length; i++)
{
// Rewrites the opcode so that we consume an ID in correct precision context.
// This is pretty hacky, but it's the most straight forward way of implementing this without adding
// lots of extra passes to rewrite all code blocks.
args[i] = consume_temporary_in_precision_context(expression_type_id(args[i]), args[i], precision);
}
}
}
// This is probably not exhaustive ...
static bool opcode_is_precision_sensitive_operation(Op op)
{
switch (op)
{
case OpFAdd:
case OpFSub:
case OpFMul:
case OpFNegate:
case OpIAdd:
case OpISub:
case OpIMul:
case OpSNegate:
case OpFMod:
case OpFDiv:
case OpFRem:
case OpSMod:
case OpSDiv:
case OpSRem:
case OpUMod:
case OpUDiv:
case OpVectorTimesMatrix:
case OpMatrixTimesVector:
case OpMatrixTimesMatrix:
case OpDPdx:
case OpDPdy:
case OpDPdxCoarse:
case OpDPdyCoarse:
case OpDPdxFine:
case OpDPdyFine:
case OpFwidth:
case OpFwidthCoarse:
case OpFwidthFine:
case OpVectorTimesScalar:
case OpMatrixTimesScalar:
case OpOuterProduct:
case OpFConvert:
case OpSConvert:
case OpUConvert:
case OpConvertSToF:
case OpConvertUToF:
case OpConvertFToU:
case OpConvertFToS:
return true;
default:
return false;
}
}
// Instructions which just load data but don't do any arithmetic operation should just inherit the decoration.
// SPIR-V doesn't require this, but it's somewhat implied it has to work this way, relaxed precision is only
// relevant when operating on the IDs, not when shuffling things around.
static bool opcode_is_precision_forwarding_instruction(Op op, uint32_t &arg_count)
{
switch (op)
{
case OpLoad:
case OpAccessChain:
case OpInBoundsAccessChain:
case OpCompositeExtract:
case OpVectorExtractDynamic:
case OpSampledImage:
case OpImage:
case OpCopyObject:
case OpImageRead:
case OpImageFetch:
case OpImageSampleImplicitLod:
case OpImageSampleProjImplicitLod:
case OpImageSampleDrefImplicitLod:
case OpImageSampleProjDrefImplicitLod:
case OpImageSampleExplicitLod:
case OpImageSampleProjExplicitLod:
case OpImageSampleDrefExplicitLod:
case OpImageSampleProjDrefExplicitLod:
case OpImageGather:
case OpImageDrefGather:
case OpImageSparseRead:
case OpImageSparseFetch:
case OpImageSparseSampleImplicitLod:
case OpImageSparseSampleProjImplicitLod:
case OpImageSparseSampleDrefImplicitLod:
case OpImageSparseSampleProjDrefImplicitLod:
case OpImageSparseSampleExplicitLod:
case OpImageSparseSampleProjExplicitLod:
case OpImageSparseSampleDrefExplicitLod:
case OpImageSparseSampleProjDrefExplicitLod:
case OpImageSparseGather:
case OpImageSparseDrefGather:
arg_count = 1;
return true;
case OpVectorShuffle:
arg_count = 2;
return true;
case OpCompositeConstruct:
return true;
default:
break;
}
return false;
}
CompilerGLSL::TemporaryCopy CompilerGLSL::handle_instruction_precision(const Instruction &instruction)
{
auto ops = stream_mutable(instruction);
auto opcode = static_cast<Op>(instruction.op);
uint32_t length = instruction.length;
if (backend.requires_relaxed_precision_analysis)
{
if (length > 2)
{
uint32_t forwarding_length = length - 2;
if (opcode_is_precision_sensitive_operation(opcode))
analyze_precision_requirements(ops[0], ops[1], &ops[2], forwarding_length);
else if (opcode == OpExtInst && length >= 5 && get<SPIRExtension>(ops[2]).ext == SPIRExtension::GLSL)
analyze_precision_requirements(ops[0], ops[1], &ops[4], forwarding_length - 2);
else if (opcode_is_precision_forwarding_instruction(opcode, forwarding_length))
forward_relaxed_precision(ops[1], &ops[2], forwarding_length);
}
Refactor out query for operation type/result IDs.
2022-05-02 13:27:09 +00:00
uint32_t result_type = 0, result_id = 0;
if (instruction_to_result_type(result_type, result_id, opcode, ops, length))
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
{
auto itr = temporary_to_mirror_precision_alias.find(ops[1]);
if (itr != temporary_to_mirror_precision_alias.end())
return { itr->second, itr->first };
}
}
return {};
}
Add -Wshadow. Fixes lots of dubious variable shadowing.
2016-05-05 07:15:25 +00:00
void CompilerGLSL::emit_instruction(const Instruction &instruction)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto ops = stream(instruction);
auto opcode = static_cast<Op>(instruction.op);
uint32_t length = instruction.length;
Initial commit.
2016-03-02 17:09:16 +00:00
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define GLSL_BOP(op) emit_binary_op(ops[0], ops[1], ops[2], ops[3], #op)
#define GLSL_BOP_CAST(op, type) \
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
emit_binary_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, \
opcode_is_sign_invariant(opcode), implicit_integer_promotion)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define GLSL_UOP(op) emit_unary_op(ops[0], ops[1], ops[2], #op)
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
#define GLSL_UOP_CAST(op) emit_unary_op_cast(ops[0], ops[1], ops[2], #op)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define GLSL_QFOP(op) emit_quaternary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], ops[5], #op)
#define GLSL_TFOP(op) emit_trinary_func_op(ops[0], ops[1], ops[2], ops[3], ops[4], #op)
#define GLSL_BFOP(op) emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], #op)
#define GLSL_BFOP_CAST(op, type) \
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
emit_binary_func_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, opcode_is_sign_invariant(opcode))
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
#define GLSL_BFOP(op) emit_binary_func_op(ops[0], ops[1], ops[2], ops[3], #op)
#define GLSL_UFOP(op) emit_unary_func_op(ops[0], ops[1], ops[2], #op)
Initial commit.
2016-03-02 17:09:16 +00:00
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
// If we need to do implicit bitcasts, make sure we do it with the correct type.
uint32_t integer_width = get_integer_width_for_instruction(instruction);
auto int_type = to_signed_basetype(integer_width);
auto uint_type = to_unsigned_basetype(integer_width);
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
// Handle C implicit integer promotion rules.
// If we get implicit promotion to int, need to make sure we cast by value to intended return type,
// otherwise, future sign-dependent operations and bitcasts will break.
bool implicit_integer_promotion = integer_width < 32 && backend.implicit_c_integer_promotion_rules &&
opcode_can_promote_integer_implicitly(opcode) &&
get<SPIRType>(ops[0]).vecsize == 1;
Add relax_nan_checks options. Makes codegen from typical D3D emulation SPIR-V more readable. Also makes cross compilation with NotEqual more sensible. It's very rare to actually need the strict NaN-checks in practice. Also, glslang now emits UnordNotEqual by default it seems, so give up trying to assume OrdNotEqual. Harmonize for UnordNotEqual as the sane default.
2022-03-03 10:04:45 +00:00
opcode = get_remapped_spirv_op(opcode);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (opcode)
{
// Dealing with memory
case OpLoad:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t ptr = ops[2];
flush_variable_declaration(ptr);
// If we're loading from memory that cannot be changed by the shader,
// just forward the expression directly to avoid needless temporaries.
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
// If an expression is mutable and forwardable, we speculate that it is immutable.
bool forward = should_forward(ptr) && forced_temporaries.find(id) == end(forced_temporaries);
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
// If loading a non-native row-major matrix, mark the expression as need_transpose.
bool need_transpose = false;
bool old_need_transpose = false;
auto *ptr_expression = maybe_get<SPIRExpression>(ptr);
Deal correctly with non-forwarded packed loads. Need to unpack the expression if we're not forwarding.
2019-07-23 14:25:19 +00:00
if (forward)
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
{
Deal correctly with non-forwarded packed loads. Need to unpack the expression if we're not forwarding.
2019-07-23 14:25:19 +00:00
// If we're forwarding the load, we're also going to forward transpose state, so don't transpose while
// taking the expression.
if (ptr_expression && ptr_expression->need_transpose)
{
old_need_transpose = true;
ptr_expression->need_transpose = false;
need_transpose = true;
}
else if (is_non_native_row_major_matrix(ptr))
need_transpose = true;
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
}
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
// If we are forwarding this load,
// don't register the read to access chain here, defer that to when we actually use the expression,
// using the add_implied_read_expression mechanism.
Deal correctly with non-forwarded packed loads. Need to unpack the expression if we're not forwarding.
2019-07-23 14:25:19 +00:00
string expr;
bool is_packed = has_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypePacked);
bool is_remapped = has_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypeID);
if (forward || (!is_packed && !is_remapped))
{
// For the simple case, we do not need to deal with repacking.
expr = to_dereferenced_expression(ptr, false);
}
else
{
// If we are not forwarding the expression, we need to unpack and resolve any physical type remapping here before
// storing the expression to a temporary.
expr = to_unpacked_expression(ptr);
}
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
MSL: Fix up input variables' vector lengths in all stages. Metal is picky about interface matching. If the types don't match exactly, down to the number of vector components, Metal fails pipline compilation. To support pipelines where the number of components consumed by the fragment shader is less than that produced by the vertex shader, we have to fix up the fragment shader to accept all the components produced.
2020-06-14 04:03:30 +00:00
auto &type = get<SPIRType>(result_type);
auto &expr_type = expression_type(ptr);
// If the expression has more vector components than the result type, insert
// a swizzle. This shouldn't happen normally on valid SPIR-V, but it might
// happen with e.g. the MSL backend replacing the type of an input variable.
if (expr_type.vecsize > type.vecsize)
expr = enclose_expression(expr + vector_swizzle(type.vecsize, 0));
MSL: Use a wrapper type for matrices in workgroup storage. The standard `matrix` type in MSL lacked a constructor in the `threadgroup` AS. This means that it was impossible to declare a `threadgroup` variable that contains a matrix. This appears to have been an oversight that was corrected in macOS 13/Xcode 14 beta 4. This workaround continues to be required, however, for older systems. To avoid changing interfaces unnecessarily (which shouldn't be a problem regardless because the old and new types take up the same amount of storage), only do this for structs if the struct is positively identified as being used for workgroup storage. I'm entirely aware this is inconsistent with the way packed matrices are handled. One of them should be changed to match the other. Not sure which one. Fixes 23 CTS tests under `dEQP-VK.memory_model.shared`.
2022-08-05 08:16:45 +00:00
if (forward && ptr_expression)
ptr_expression->need_transpose = old_need_transpose;
MSL: Don't use a bitcast for tessellation levels in tesc shaders. `half` cannot be bitcasted to `float`, because the two types are not the same size. Use an expanding cast instead. We were already doing this for stores to the tessellation levels; why I didn't also do this for loads is beyond me.
2020-10-14 20:04:03 +00:00
// We might need to cast in order to load from a builtin.
MSL: Workaround compiler crashes when using threadgroup bool. Promote to short instead and do simple casts on load/store instead. Not 100% complete fix since structs can contain booleans, but this is getting into pretty ridiculously complicated territory.
2021-10-25 08:55:11 +00:00
cast_from_variable_load(ptr, expr, type);
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
MSL: Use a wrapper type for matrices in workgroup storage. The standard `matrix` type in MSL lacked a constructor in the `threadgroup` AS. This means that it was impossible to declare a `threadgroup` variable that contains a matrix. This appears to have been an oversight that was corrected in macOS 13/Xcode 14 beta 4. This workaround continues to be required, however, for older systems. To avoid changing interfaces unnecessarily (which shouldn't be a problem regardless because the old and new types take up the same amount of storage), only do this for structs if the struct is positively identified as being used for workgroup storage. I'm entirely aware this is inconsistent with the way packed matrices are handled. One of them should be changed to match the other. Not sure which one. Fixes 23 CTS tests under `dEQP-VK.memory_model.shared`.
2022-08-05 08:16:45 +00:00
if (forward && ptr_expression)
ptr_expression->need_transpose = false;
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
// We might be trying to load a gl_Position[N], where we should be
// doing float4[](gl_in[i].gl_Position, ...) instead.
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
// Similar workarounds are required for input arrays in tessellation.
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
// Also, loading from gl_SampleMask array needs special unroll.
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
unroll_array_from_complex_load(id, ptr, expr);
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
if (!type_is_opaque_value(type) && has_decoration(ptr, DecorationNonUniform))
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
{
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
// If we're loading something non-opaque, we need to handle non-uniform descriptor access.
convert_non_uniform_expression(expr, ptr);
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
}
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
Deal correctly with non-forwarded packed loads. Need to unpack the expression if we're not forwarding.
2019-07-23 14:25:19 +00:00
if (forward && ptr_expression)
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
ptr_expression->need_transpose = old_need_transpose;
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
bool flattened = ptr_expression && flattened_buffer_blocks.count(ptr_expression->loaded_from) != 0;
if (backend.needs_row_major_load_workaround && !is_non_native_row_major_matrix(ptr) && !flattened)
rewrite_load_for_wrapped_row_major(expr, result_type, ptr);
Properly track read dependencies for UAV access chain.
2018-07-09 12:02:50 +00:00
// By default, suppress usage tracking since using same expression multiple times does not imply any extra work.
Fix a lot of redundant code when loading flattened composites.
2018-07-06 08:57:23 +00:00
// However, if we try to load a complex, composite object from a flattened buffer,
// we should avoid emitting the same code over and over and lower the result to a temporary.
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
bool usage_tracking = flattened && (type.basetype == SPIRType::Struct || (type.columns > 1));
Fix a lot of redundant code when loading flattened composites.
2018-07-06 08:57:23 +00:00
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
SPIRExpression *e = nullptr;
MSL: Deal with loading non-value-type arrays.
2020-06-18 10:46:39 +00:00
if (!forward && expression_is_non_value_type_array(ptr))
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
{
// Complicated load case where we need to make a copy of ptr, but we cannot, because
// it is an array, and our backend does not support arrays as value types.
// Emit the temporary, and copy it explicitly.
e = &emit_uninitialized_temporary_expression(result_type, id);
MSL: Handle more complex array copy scenarios with bool <-> short.
2023-06-06 13:05:56 +00:00
emit_array_copy(nullptr, id, ptr, StorageClassFunction, get_expression_effective_storage_class(ptr));
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
}
else
e = &emit_op(result_type, id, expr, forward, !usage_tracking);
e->need_transpose = need_transpose;
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
register_read(id, ptr, forward);
CompilerMSL allow swizzle of packed_float3 vectors by unpacking to float3. Pass packed indicator back through OpAccessChain and OpLoad. Unpack packed vector before applying swizzle. Add packed swizzle test.
2018-01-05 22:46:56 +00:00
Deal correctly with non-forwarded packed loads. Need to unpack the expression if we're not forwarding.
2019-07-23 14:25:19 +00:00
if (forward)
{
// Pass through whether the result is of a packed type and the physical type ID.
if (has_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypePacked))
set_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked);
if (has_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypeID))
{
set_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID,
get_extended_decoration(ptr, SPIRVCrossDecorationPhysicalTypeID));
}
}
else
Refactor out packed expressions to extended decorations. Can't safely just cast to the original enum without lots of hacks.
2019-01-17 10:22:24 +00:00
{
Deal correctly with non-forwarded packed loads. Need to unpack the expression if we're not forwarding.
2019-07-23 14:25:19 +00:00
// This might have been set on an earlier compilation iteration, force it to be unset.
unset_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked);
unset_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID);
Refactor out packed expressions to extended decorations. Can't safely just cast to the original enum without lots of hacks.
2019-01-17 10:22:24 +00:00
}
CompilerMSL allow swizzle of packed_float3 vectors by unpacking to float3. Pass packed indicator back through OpAccessChain and OpLoad. Unpack packed vector before applying swizzle. Add packed swizzle test.
2018-01-05 22:46:56 +00:00
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
inherit_expression_dependencies(id, ptr);
if (forward)
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
add_implied_read_expression(*e, ptr);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpInBoundsAccessChain:
case OpAccessChain:
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
case OpPtrAccessChain:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
auto *var = maybe_get<SPIRVariable>(ops[2]);
if (var)
flush_variable_declaration(var->self);
// If the base is immutable, the access chain pointer must also be.
Fix various corner cases with expression dependencies. There was a potential problem if variables were invalidated and SPIR-V read expressions which depended on other expression which in turn depended on the invalidated variable. Also fixes issue where variables were considered immutable if they were forwardable. This allowed some incorrect optimizations to slip through.
2016-07-12 12:33:04 +00:00
// If an expression is mutable and forwardable, we speculate that it is immutable.
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
AccessChainMeta meta;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
bool ptr_chain = opcode == OpPtrAccessChain;
HLSL: Make --flatten-ubo work correctly
2022-02-16 12:53:24 +00:00
auto &target_type = get<SPIRType>(ops[0]);
auto e = access_chain(ops[2], &ops[3], length - 3, target_type, &meta, ptr_chain);
// If the base is flattened UBO of struct type, the expression has to be a composite.
// In that case, backends which do not support inline syntax need it to be bound to a temporary.
// Otherwise, invalid expressions like ({UBO[0].xyz, UBO[0].w, UBO[1]}).member are emitted.
bool requires_temporary = false;
if (flattened_buffer_blocks.count(ops[2]) && target_type.basetype == SPIRType::Struct)
requires_temporary = !backend.can_declare_struct_inline;
auto &expr = requires_temporary ?
Qualify std::move. Clang added -Wunqualified-std-cast-call in https://reviews.llvm.org/D119670, which warns on unqualified std::move and std::forward calls. This change qualifies these calls to allow the project to build on HEAD Clang -Werror.
2022-03-02 23:02:38 +00:00
emit_op(ops[0], ops[1], std::move(e), false) :
set<SPIRExpression>(ops[1], std::move(e), ops[0], should_forward(ops[2]));
Handle inout properly with split access chains. Found some other issues. Had some bugs with variable writes not properly invalidating if writes came from split access chains.
2018-05-11 08:14:20 +00:00
auto *backing_variable = maybe_get_backing_variable(ops[2]);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
expr.loaded_from = backing_variable ? backing_variable->self : ID(ops[2]);
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
expr.need_transpose = meta.need_transpose;
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
expr.access_chain = true;
track access to meshlet position.y, via SPIRExpression
2023-07-01 13:49:35 +00:00
expr.access_meshlet_position_y = meta.access_meshlet_position_y;
CompilerMSL allow swizzle of packed_float3 vectors by unpacking to float3. Pass packed indicator back through OpAccessChain and OpLoad. Unpack packed vector before applying swizzle. Add packed swizzle test.
2018-01-05 22:46:56 +00:00
// Mark the result as being packed. Some platforms handled packed vectors differently than non-packed.
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
if (meta.storage_is_packed)
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
set_extended_decoration(ops[1], SPIRVCrossDecorationPhysicalTypePacked);
if (meta.storage_physical_type != 0)
set_extended_decoration(ops[1], SPIRVCrossDecorationPhysicalTypeID, meta.storage_physical_type);
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
if (meta.storage_is_invariant)
set_decoration(ops[1], DecorationInvariant);
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
if (meta.flattened_struct)
flattened_structs[ops[1]] = true;
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
if (meta.relaxed_precision && backend.requires_relaxed_precision_analysis)
set_decoration(ops[1], DecorationRelaxedPrecision);
Handle invariant decoration more robustly. Avoids certain cases of variance between translation units by forcing every dependent expression of a store to be temporary. Should avoid the major failure cases where invariance matters.
2018-11-22 10:55:57 +00:00
Do not eagerly invalidate all active variables on a branch. This is not necessary, as we must emit an invalidating store before we potentially consume an invalid expression. In fact, we're a bit conservative here in this case for example: int tmp = variable; if (...) { variable = 10; } else { // Consuming tmp here is fine, but it was // invalidated while emitting other branch. // Technically, we need to study if there is an invalidating store // in the CFG between the loading block and this block, and the other // branch will not be a part of that analysis. int tmp2 = tmp * tmp; } Fixing this case means complex CFG traversal *everywhere*, and it feels like overkill. Fixing this exposed a bug with access chains, so fix a bug where expression dependencies were not inherited properly in access chains. Access chains are now considered forwarded if there is at least one dependency which is also forwarded.
2019-07-24 09:10:18 +00:00
// If we have some expression dependencies in our access chain, this access chain is technically a forwarded
// temporary which could be subject to invalidation.
// Need to assume we're forwarded while calling inherit_expression_depdendencies.
forwarded_temporaries.insert(ops[1]);
// The access chain itself is never forced to a temporary, but its dependencies might.
suppressed_usage_tracking.insert(ops[1]);
Register implied expression reads in OpLoad/OpAccessChain. This is required to avoid relying on complex sub-expression elimination in compilers, and generates cleaner code. The problem case is if a complex expression is used in an access chain, like: Composite comp = buffer[texture(...)]; vec4 a = comp.a + comp.b + comp.c; Before, we did not have common subexpression tracking for OpLoad/OpAccessChain, so we easily ended up with code like: vec4 a = buffer[texture(...)].a + buffer[texture(...)].b + buffer[texture(...)].c; A good compiler will optimize this, but we should not rely on it, and forcing texture(...) to a temporary also looks better. The solution is to add a vector "implied_expression_reads", which works similarly to expression_dependencies. We also need an extra mechanism in to_expression which lets us skip expression read checking and do it later. E.g. for expr -> access chain -> load, we should only trigger a read of expr when using the loaded expression.
2019-01-04 12:19:50 +00:00
for (uint32_t i = 2; i < length; i++)
{
inherit_expression_dependencies(ops[1], ops[i]);
add_implied_read_expression(expr, ops[i]);
}
Do not eagerly invalidate all active variables on a branch. This is not necessary, as we must emit an invalidating store before we potentially consume an invalid expression. In fact, we're a bit conservative here in this case for example: int tmp = variable; if (...) { variable = 10; } else { // Consuming tmp here is fine, but it was // invalidated while emitting other branch. // Technically, we need to study if there is an invalidating store // in the CFG between the loading block and this block, and the other // branch will not be a part of that analysis. int tmp2 = tmp * tmp; } Fixing this case means complex CFG traversal *everywhere*, and it feels like overkill. Fixing this exposed a bug with access chains, so fix a bug where expression dependencies were not inherited properly in access chains. Access chains are now considered forwarded if there is at least one dependency which is also forwarded.
2019-07-24 09:10:18 +00:00
// If we have no dependencies after all, i.e., all indices in the access chain are immutable temporaries,
// we're not forwarded after all.
if (expr.expression_dependencies.empty())
forwarded_temporaries.erase(ops[1]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpStore:
{
auto *var = maybe_get<SPIRVariable>(ops[0]);
if (var && var->statically_assigned)
var->static_expression = ops[1];
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
else if (var && var->loop_variable && !var->loop_variable_enable)
var->static_expression = ops[1];
Do not mask writes to remapped variables in all cases. If they don't have a static expression we should still write to it.
2020-05-28 09:49:28 +00:00
else if (var && var->remapped_variable && var->static_expression)
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
{
// Skip the write.
}
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
else if (flattened_structs.count(ops[0]))
Fix cases for flattened struct write. Handle writing the entire struct as well as writing the elements individually.
2017-02-23 18:03:07 +00:00
{
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
store_flattened_struct(ops[0], ops[1]);
Fix cases for flattened struct write. Handle writing the entire struct as well as writing the elements individually.
2017-02-23 18:03:07 +00:00
register_write(ops[0]);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
{
Avoid unintentional name conflict with HLSL backend.
2019-01-17 11:21:16 +00:00
emit_store_statement(ops[0], ops[1]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// Storing a pointer results in a variable pointer, so we must conservatively assume
// we can write through it.
if (expression_type(ops[1]).pointer)
register_write(ops[1]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpArrayLength:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Run format_all.sh.
2019-01-17 10:29:50 +00:00
auto e = access_chain_internal(ops[2], &ops[3], length - 3, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr);
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
if (has_decoration(ops[2], DecorationNonUniform))
convert_non_uniform_expression(e, ops[2]);
GLSL: Return correct sign for OpArrayLength. .length() returns int, not uint ...
2019-05-07 17:02:32 +00:00
set<SPIRExpression>(id, join(type_to_glsl(get<SPIRType>(result_type)), "(", e, ".length())"), result_type,
true);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
// Function calls
case OpFunctionCall:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t func = ops[2];
const auto *arg = &ops[3];
length -= 3;
auto &callee = get<SPIRFunction>(func);
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
auto &return_type = get<SPIRType>(callee.return_type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
bool pure = function_is_pure(callee);
Mark function call results as control dependent as necessary. Inner function calls can contain flow-control sensitive code. In this case, the function call itself must inherit the control-dependence. Rarely happens in practice since optimized code with SSA tends to inline.
2024-05-10 12:52:24 +00:00
bool control_dependent = function_is_control_dependent(callee);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
bool callee_has_out_variables = false;
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
bool emit_return_value_as_argument = false;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Invalidate out variables passed to functions since they can be OpStore'd to.
for (uint32_t i = 0; i < length; i++)
{
if (callee.arguments[i].write_count)
{
register_call_out_argument(arg[i]);
callee_has_out_variables = true;
}
flush_variable_declaration(arg[i]);
}
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
if (!return_type.array.empty() && !backend.can_return_array)
{
callee_has_out_variables = true;
emit_return_value_as_argument = true;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!pure)
register_impure_function_call();
string funexpr;
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<string> arglist;
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
funexpr += to_name(func) + "(";
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
if (emit_return_value_as_argument)
{
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
statement(type_to_glsl(return_type), " ", to_name(id), type_to_array_glsl(return_type, 0), ";");
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
arglist.push_back(to_name(id));
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (uint32_t i = 0; i < length; i++)
{
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
// Do not pass in separate images or samplers if we're remapping
// to combined image samplers.
if (skip_argument(arg[i]))
continue;
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
arglist.push_back(to_func_call_arg(callee.arguments[i], arg[i]));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Pass down combined samplers to callees.
2016-09-11 11:20:35 +00:00
for (auto &combined : callee.combined_parameters)
{
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
auto image_id = combined.global_image ? combined.image_id : VariableID(arg[combined.image_id]);
auto sampler_id = combined.global_sampler ? combined.sampler_id : VariableID(arg[combined.sampler_id]);
Consistently use "image" nomenclature for separate images.
2016-09-11 11:47:06 +00:00
arglist.push_back(to_combined_image_sampler(image_id, sampler_id));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Merge Brenwill fork with upstream.
2016-10-19 21:09:51 +00:00
Run clang-format.
2016-10-24 13:24:24 +00:00
append_global_func_args(callee, length, arglist);
Merge Brenwill fork with upstream.
2016-10-19 21:09:51 +00:00
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
funexpr += merge(arglist);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
funexpr += ")";
Add support for generic remapping of variables.
2016-07-06 09:04:06 +00:00
// Check for function call constraints.
check_function_call_constraints(arg, length);
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
if (return_type.basetype != SPIRType::Void)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
// If the function actually writes to an out variable,
// take the conservative route and do not forward.
// The problem is that we might not read the function
// result (and emit the function) before an out variable
// is read (common case when return value is ignored!
// In order to avoid start tracking invalid variables,
// just avoid the forwarding problem altogether.
bool forward = args_will_forward(id, arg, length, pure) && !callee_has_out_variables && pure &&
(forced_temporaries.find(id) == end(forced_temporaries));
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
if (emit_return_value_as_argument)
{
statement(funexpr, ";");
set<SPIRExpression>(id, to_name(id), result_type, true);
}
else
emit_op(result_type, id, funexpr, forward);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Function calls are implicit loads from all variables in question.
// Set dependencies for them.
for (uint32_t i = 0; i < length; i++)
register_read(id, arg[i], forward);
// If we're going to forward the temporary result,
// put dependencies on every variable that must not change.
if (forward)
register_global_read_dependencies(callee, id);
}
else
statement(funexpr, ";");
Mark function call results as control dependent as necessary. Inner function calls can contain flow-control sensitive code. In this case, the function call itself must inherit the control-dependence. Rarely happens in practice since optimized code with SSA tends to inline.
2024-05-10 12:52:24 +00:00
if (control_dependent)
register_control_dependent_expression(id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
// Composite munging
case OpCompositeConstruct:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Run format_all.sh.
2018-03-09 14:26:36 +00:00
const auto *const elems = &ops[2];
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
length -= 2;
bool forward = true;
for (uint32_t i = 0; i < length; i++)
forward = forward && should_forward(elems[i]);
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
auto &out_type = get<SPIRType>(result_type);
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
auto *in_type = length > 0 ? &expression_type(elems[0]) : nullptr;
Handle empty struct declarations with best effort. This "feature" is a bit icky as we have no useful representation of it, so never emit code which has anything to do with empty structs.
2017-10-06 11:03:34 +00:00
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
// Only splat if we have vector constructors.
// Arrays and structs must be initialized properly in full.
bool composite = !out_type.array.empty() || out_type.basetype == SPIRType::Struct;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
bool splat = false;
bool swizzle_splat = false;
if (in_type)
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
{
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
splat = in_type->vecsize == 1 && in_type->columns == 1 && !composite && backend.use_constructor_splatting;
swizzle_splat = in_type->vecsize == 1 && in_type->columns == 1 && backend.can_swizzle_scalar;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (ir.ids[elems[0]].get_type() == TypeConstant && !type_is_floating_point(*in_type))
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
{
// Cannot swizzle literal integers as a special case.
swizzle_splat = false;
}
Fix swizzling of integers. Add scalar swizzling to constant composites as well.
2018-01-04 12:16:56 +00:00
}
Swizzle scalars when splatting in HLSL.
2017-12-12 11:52:45 +00:00
if (splat || swizzle_splat)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
uint32_t input = elems[0];
for (uint32_t i = 0; i < length; i++)
Swizzle scalars when splatting in HLSL.
2017-12-12 11:52:45 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (input != elems[i])
Swizzle scalars when splatting in HLSL.
2017-12-12 11:52:45 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
splat = false;
Swizzle scalars when splatting in HLSL.
2017-12-12 11:52:45 +00:00
swizzle_splat = false;
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Fix HLSL regression with struct declaration. It actually worked surprisingly. Fix it properly.
2018-01-23 15:36:20 +00:00
if (out_type.basetype == SPIRType::Struct && !backend.can_declare_struct_inline)
forward = false;
Do not declare constant composites inline in HLSL. Move arrays and structs out to their own global static constants. Also, replace illegal names in HLSL as well.
2018-02-02 09:10:17 +00:00
if (!out_type.array.empty() && !backend.can_declare_arrays_inline)
forward = false;
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
if (type_is_empty(out_type) && !backend.supports_empty_struct)
forward = false;
Fix HLSL regression with struct declaration. It actually worked surprisingly. Fix it properly.
2018-01-23 15:36:20 +00:00
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
string constructor_op;
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
if (backend.use_initializer_list && composite)
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
{
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
bool needs_trailing_tracket = false;
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
// Only use this path if we are building composites.
// This path cannot be used for arithmetic.
Only declare typed initializer list for non-array types. Also, cleanup now redundant constant_expression virtualization for MSL.
2018-09-10 08:04:17 +00:00
if (backend.use_typed_initializer_list && out_type.basetype == SPIRType::Struct && out_type.array.empty())
Fix HLSL regression with struct declaration. It actually worked surprisingly. Fix it properly.
2018-01-23 15:36:20 +00:00
constructor_op += type_to_glsl_constructor(get<SPIRType>(result_type));
MSL: Add a workaround path to force native arrays for everything.
2020-02-24 11:47:14 +00:00
else if (backend.use_typed_initializer_list && backend.array_is_value_type && !out_type.array.empty())
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
{
// MSL path. Array constructor is baked into type here, do not use _constructor variant.
constructor_op += type_to_glsl_constructor(get<SPIRType>(result_type)) + "(";
needs_trailing_tracket = true;
}
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
constructor_op += "{ ";
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
if (type_is_empty(out_type) && !backend.supports_empty_struct)
constructor_op += "0";
else if (splat)
MSL: Fix regression with OpCompositeConstruct from std140 float[]. Simple fix, just need to use to_unpacked_expression rather than to_expression here to deal with this.
2019-10-11 09:21:43 +00:00
constructor_op += to_unpacked_expression(elems[0]);
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
else
Do not merge swizzles for anything other than vectors.
2018-01-22 08:52:57 +00:00
constructor_op += build_composite_combiner(result_type, elems, length);
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
constructor_op += " }";
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
if (needs_trailing_tracket)
constructor_op += ")";
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
}
Swizzle scalars when splatting in HLSL.
2017-12-12 11:52:45 +00:00
else if (swizzle_splat && !composite)
Fix compatibility with FXC.
2017-12-12 10:03:46 +00:00
{
MSL: Fix regression with OpCompositeConstruct from std140 float[]. Simple fix, just need to use to_unpacked_expression rather than to_expression here to deal with this.
2019-10-11 09:21:43 +00:00
constructor_op = remap_swizzle(get<SPIRType>(result_type), 1, to_unpacked_expression(elems[0]));
Fix compatibility with FXC.
2017-12-12 10:03:46 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
{
constructor_op = type_to_glsl_constructor(get<SPIRType>(result_type)) + "(";
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
if (type_is_empty(out_type) && !backend.supports_empty_struct)
constructor_op += "0";
else if (splat)
MSL: Fix regression with OpCompositeConstruct from std140 float[]. Simple fix, just need to use to_unpacked_expression rather than to_expression here to deal with this.
2019-10-11 09:21:43 +00:00
constructor_op += to_unpacked_expression(elems[0]);
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
else
Do not merge swizzles for anything other than vectors.
2018-01-22 08:52:57 +00:00
constructor_op += build_composite_combiner(result_type, elems, length);
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
constructor_op += ")";
}
MSL: Support array-of-arrays composite construction.
2018-09-12 08:25:51 +00:00
if (!constructor_op.empty())
{
emit_op(result_type, id, constructor_op, forward);
for (uint32_t i = 0; i < length; i++)
inherit_expression_dependencies(id, elems[i]);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpVectorInsertDynamic:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t vec = ops[2];
uint32_t comp = ops[3];
uint32_t index = ops[4];
flush_variable_declaration(vec);
// Make a copy, then use access chain to store the variable.
statement(declare_temporary(result_type, id), to_expression(vec), ";");
set<SPIRExpression>(id, to_name(id), result_type, true);
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
auto chain = access_chain_internal(id, &index, 1, 0, nullptr);
MSL: Fix OpCompositeInsert and OpVectorInsertDynamic. Need to take care of unpacked RHS expressions.
2020-09-02 08:27:39 +00:00
statement(chain, " = ", to_unpacked_expression(comp), ";");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpVectorExtractDynamic:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
auto expr = access_chain_internal(ops[2], &ops[3], 1, 0, nullptr);
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
emit_op(result_type, id, expr, should_forward(ops[2]));
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(id, ops[2]);
inherit_expression_dependencies(id, ops[3]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpCompositeExtract:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
length -= 3;
auto &type = get<SPIRType>(result_type);
Only split expression in OpCompositeExtract if we forward the temporary.
2016-06-23 10:11:36 +00:00
// We can only split the expression here if our expression is forwarded as a temporary.
bool allow_base_expression = forced_temporaries.find(id) == end(forced_temporaries);
Do not allow base expressions when extracting struct members.
2017-11-20 20:32:13 +00:00
// Do not allow base expression for struct members. We risk doing "swizzle" optimizations in this case.
auto &composite_type = expression_type(ops[2]);
Deal better with CompositeExtract from constant composite. There is no good reason for applications to emit this kind of code, but some do. Special case this scenario.
2021-01-22 11:17:05 +00:00
bool composite_type_is_complex = composite_type.basetype == SPIRType::Struct || !composite_type.array.empty();
if (composite_type_is_complex)
Do not allow base expressions when extracting struct members.
2017-11-20 20:32:13 +00:00
allow_base_expression = false;
MSL: Do not use base expression with PhysicalTypeID OpCompositeExtract. Similar reasoning as packed expressions.
2020-04-07 16:22:14 +00:00
// Packed expressions or physical ID mapped expressions cannot be split up.
if (has_extended_decoration(ops[2], SPIRVCrossDecorationPhysicalTypePacked) ||
has_extended_decoration(ops[2], SPIRVCrossDecorationPhysicalTypeID))
Access chain into packed vectors as arrays. Cleaner and should be more compatible with storing to packed vector elements. Fix CompositeExtract bug with packed vectors on MSL.
2018-03-13 11:13:01 +00:00
allow_base_expression = false;
Do not allow base expressions for non-native row-major matrices.
2019-08-27 09:41:54 +00:00
// Cannot use base expression for row-major matrix row-extraction since we need to interleave access pattern
// into the base expression.
if (is_non_native_row_major_matrix(ops[2]))
allow_base_expression = false;
Forward meta information in OpCompositeExtract. Just like OpAccessChain we need to make use of the meta information available to use from access_chain_internal as we can extract a packed vector or transposed vector from a composite, not just memory load.
2019-01-07 09:43:55 +00:00
AccessChainMeta meta;
SPIRExpression *e = nullptr;
Deal better with CompositeExtract from constant composite. There is no good reason for applications to emit this kind of code, but some do. Special case this scenario.
2021-01-22 11:17:05 +00:00
auto *c = maybe_get<SPIRConstant>(ops[2]);
Forward meta information in OpCompositeExtract. Just like OpAccessChain we need to make use of the meta information available to use from access_chain_internal as we can extract a packed vector or transposed vector from a composite, not just memory load.
2019-01-07 09:43:55 +00:00
Deal better with CompositeExtract from constant composite. There is no good reason for applications to emit this kind of code, but some do. Special case this scenario.
2021-01-22 11:17:05 +00:00
if (c && !c->specialization && !composite_type_is_complex)
{
auto expr = to_extract_constant_composite_expression(result_type, *c, ops + 3, length);
e = &emit_op(result_type, id, expr, true, true);
}
else if (allow_base_expression && should_forward(ops[2]) && type.vecsize == 1 && type.columns == 1 && length == 1)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Deal better with CompositeExtract from constant composite. There is no good reason for applications to emit this kind of code, but some do. Special case this scenario.
2021-01-22 11:17:05 +00:00
// Only apply this optimization if result is scalar.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// We want to split the access chain from the base.
// This is so we can later combine different CompositeExtract results
// with CompositeConstruct without emitting code like
//
// vec3 temp = texture(...).xyz
// vec4(temp.x, temp.y, temp.z, 1.0).
//
// when we actually wanted to emit this
// vec4(texture(...).xyz, 1.0).
//
// Including the base will prevent this and would trigger multiple reads
// from expression causing it to be forced to an actual temporary in GLSL.
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
auto expr = access_chain_internal(ops[2], &ops[3], length,
MSL: Do not consider effective storage for any composite.
2021-04-06 09:35:04 +00:00
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_CHAIN_ONLY_BIT |
ACCESS_CHAIN_FORCE_COMPOSITE_BIT, &meta);
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
e = &emit_op(result_type, id, expr, true, should_suppress_usage_tracking(ops[2]));
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(id, ops[2]);
Forward meta information in OpCompositeExtract. Just like OpAccessChain we need to make use of the meta information available to use from access_chain_internal as we can extract a packed vector or transposed vector from a composite, not just memory load.
2019-01-07 09:43:55 +00:00
e->base_expression = ops[2];
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
if (meta.relaxed_precision && backend.requires_relaxed_precision_analysis)
set_decoration(ops[1], DecorationRelaxedPrecision);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
MSL: Do not consider effective storage for any composite.
2021-04-06 09:35:04 +00:00
auto expr = access_chain_internal(ops[2], &ops[3], length,
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_FORCE_COMPOSITE_BIT, &meta);
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
e = &emit_op(result_type, id, expr, should_forward(ops[2]), should_suppress_usage_tracking(ops[2]));
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(id, ops[2]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Forward meta information in OpCompositeExtract. Just like OpAccessChain we need to make use of the meta information available to use from access_chain_internal as we can extract a packed vector or transposed vector from a composite, not just memory load.
2019-01-07 09:43:55 +00:00
// Pass through some meta information to the loaded expression.
// We can still end up loading a buffer type to a variable, then CompositeExtract from it
// instead of loading everything through an access chain.
e->need_transpose = meta.need_transpose;
if (meta.storage_is_packed)
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
set_extended_decoration(id, SPIRVCrossDecorationPhysicalTypePacked);
if (meta.storage_physical_type != 0)
set_extended_decoration(id, SPIRVCrossDecorationPhysicalTypeID, meta.storage_physical_type);
Forward meta information in OpCompositeExtract. Just like OpAccessChain we need to make use of the meta information available to use from access_chain_internal as we can extract a packed vector or transposed vector from a composite, not just memory load.
2019-01-07 09:43:55 +00:00
if (meta.storage_is_invariant)
set_decoration(id, DecorationInvariant);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpCompositeInsert:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t obj = ops[2];
uint32_t composite = ops[3];
const auto *elems = &ops[4];
length -= 4;
flush_variable_declaration(composite);
Attempt more optimal codegen for OpCompositeInsert. Speculate that we can modify the SSA value in-place. As long as it is not used after the modify, this is fine. Also need to make sure we don't attempt to RMW something that is impossible to modify.
2022-05-18 10:26:20 +00:00
// CompositeInsert requires a copy + modification, but this is very awkward code in HLL.
// Speculate that the input composite is no longer used, and we can modify it in-place.
// There are various scenarios where this is not possible to satisfy.
bool can_modify_in_place = true;
forced_temporaries.insert(id);
// Cannot safely RMW PHI variables since they have no way to be invalidated,
// forcing temporaries is not going to help.
// This is similar for Constant and Undef inputs.
// The only safe thing to RMW is SPIRExpression.
Do not optimize OpCompositeInsert for hoisted temporaries. We cannot track uses that happens in subsequent loop iterations, so have to be very careful. Fixes regression introduced after this was added.
2022-08-09 10:44:57 +00:00
// If the expression has already been used (i.e. used in a continue block), we have to keep using
// that loop variable, since we won't be able to override the expression after the fact.
// If the composite is hoisted, we might never be able to properly invalidate any usage
// of that composite in a subsequent loop iteration.
Attempt more optimal codegen for OpCompositeInsert. Speculate that we can modify the SSA value in-place. As long as it is not used after the modify, this is fine. Also need to make sure we don't attempt to RMW something that is impossible to modify.
2022-05-18 10:26:20 +00:00
if (invalid_expressions.count(composite) ||
block_composite_insert_overwrite.count(composite) ||
Do not optimize OpCompositeInsert for hoisted temporaries. We cannot track uses that happens in subsequent loop iterations, so have to be very careful. Fixes regression introduced after this was added.
2022-08-09 10:44:57 +00:00
hoisted_temporaries.count(id) || hoisted_temporaries.count(composite) ||
Attempt more optimal codegen for OpCompositeInsert. Speculate that we can modify the SSA value in-place. As long as it is not used after the modify, this is fine. Also need to make sure we don't attempt to RMW something that is impossible to modify.
2022-05-18 10:26:20 +00:00
maybe_get<SPIRExpression>(composite) == nullptr)
{
can_modify_in_place = false;
}
else if (backend.requires_relaxed_precision_analysis &&
has_decoration(composite, DecorationRelaxedPrecision) !=
has_decoration(id, DecorationRelaxedPrecision) &&
get<SPIRType>(result_type).basetype != SPIRType::Struct)
{
// Similarly, if precision does not match for input and output,
// we cannot alias them. If we write a composite into a relaxed precision
// ID, we might get a false truncation.
can_modify_in_place = false;
}
if (can_modify_in_place)
{
// Have to make sure the modified SSA value is bound to a temporary so we can modify it in-place.
if (!forced_temporaries.count(composite))
force_temporary_and_recompile(composite);
auto chain = access_chain_internal(composite, elems, length, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr);
statement(chain, " = ", to_unpacked_expression(obj), ";");
set<SPIRExpression>(id, to_expression(composite), result_type, true);
invalid_expressions.insert(composite);
composite_insert_overwritten.insert(composite);
}
else
{
if (maybe_get<SPIRUndef>(composite) != nullptr)
{
emit_uninitialized_temporary_expression(result_type, id);
}
else
{
// Make a copy, then use access chain to store the variable.
statement(declare_temporary(result_type, id), to_expression(composite), ";");
set<SPIRExpression>(id, to_name(id), result_type, true);
}
auto chain = access_chain_internal(id, elems, length, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr);
statement(chain, " = ", to_unpacked_expression(obj), ";");
}
Always make a copy when handling OpCompositeInsert The modified object might not be mutable (e.g. shader input). Added a test for the case when this happens.
2017-06-26 17:32:53 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
Distinguish between cross edges and back edges. Handle the weird opcodes CopyMemory/CopyObject.
2016-11-18 08:59:54 +00:00
case OpCopyMemory:
{
uint32_t lhs = ops[0];
uint32_t rhs = ops[1];
if (lhs != rhs)
{
Handle edge cases in OpCopyMemory. Implement this by synthesizing an OpLoad/OpStore pair instead.
2021-03-08 13:09:32 +00:00
uint32_t &tmp_id = extra_sub_expressions[instruction.offset | EXTRA_SUB_EXPRESSION_TYPE_STREAM_OFFSET];
if (!tmp_id)
tmp_id = ir.increase_bound_by(1);
uint32_t tmp_type_id = expression_type(rhs).parent_type;
EmbeddedInstruction fake_load, fake_store;
fake_load.op = OpLoad;
fake_load.length = 3;
fake_load.ops.push_back(tmp_type_id);
fake_load.ops.push_back(tmp_id);
fake_load.ops.push_back(rhs);
fake_store.op = OpStore;
fake_store.length = 2;
fake_store.ops.push_back(lhs);
fake_store.ops.push_back(tmp_id);
// Load and Store do a *lot* of workarounds, and we'd like to reuse them as much as possible.
// Synthesize a fake Load and Store pair for CopyMemory.
emit_instruction(fake_load);
emit_instruction(fake_store);
Distinguish between cross edges and back edges. Handle the weird opcodes CopyMemory/CopyObject.
2016-11-18 08:59:54 +00:00
}
break;
}
Basic implementation of OpCopyLogical.
2020-01-06 10:47:26 +00:00
case OpCopyLogical:
{
// This is used for copying object of different types, arrays and structs.
// We need to unroll the copy, element-by-element.
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t rhs = ops[2];
emit_uninitialized_temporary_expression(result_type, id);
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
emit_copy_logical_type(id, result_type, rhs, expression_type_id(rhs), {});
Basic implementation of OpCopyLogical.
2020-01-06 10:47:26 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpCopyObject:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t rhs = ops[2];
Distinguish between cross edges and back edges. Handle the weird opcodes CopyMemory/CopyObject.
2016-11-18 08:59:54 +00:00
bool pointer = get<SPIRType>(result_type).pointer;
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
auto *chain = maybe_get<SPIRAccessChain>(rhs);
MSL: Support run-time sized image and sampler arrays (GL_EXT_nonuniform_qualifier/SPV_EXT_descriptor_indexing). MSLResourceBinding includes array size through API, and substitutes in that size if the image or sampler array is not explicitly sized. OpCopyObject supports SPIRCombinedImageSampler type in MSL.
2020-10-29 22:50:42 +00:00
auto *imgsamp = maybe_get<SPIRCombinedImageSampler>(rhs);
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
if (chain)
{
// Cannot lower to a SPIRExpression, just copy the object.
auto &e = set<SPIRAccessChain>(id, *chain);
e.self = id;
}
MSL: Support run-time sized image and sampler arrays (GL_EXT_nonuniform_qualifier/SPV_EXT_descriptor_indexing). MSLResourceBinding includes array size through API, and substitutes in that size if the image or sampler array is not explicitly sized. OpCopyObject supports SPIRCombinedImageSampler type in MSL.
2020-10-29 22:50:42 +00:00
else if (imgsamp)
{
// Cannot lower to a SPIRExpression, just copy the object.
// GLSL does not currently use this type and will never get here, but MSL does.
Minor format and typo updates from code review.
2020-10-30 20:05:44 +00:00
// Handled here instead of CompilerMSL for better integration and general handling,
MSL: Support run-time sized image and sampler arrays (GL_EXT_nonuniform_qualifier/SPV_EXT_descriptor_indexing). MSLResourceBinding includes array size through API, and substitutes in that size if the image or sampler array is not explicitly sized. OpCopyObject supports SPIRCombinedImageSampler type in MSL.
2020-10-29 22:50:42 +00:00
// and in case GLSL or other subclasses require it in the future.
auto &e = set<SPIRCombinedImageSampler>(id, *imgsamp);
e.self = id;
}
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
else if (expression_is_lvalue(rhs) && !pointer)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
// Need a copy.
Distinguish between cross edges and back edges. Handle the weird opcodes CopyMemory/CopyObject.
2016-11-18 08:59:54 +00:00
// For pointer types, we copy the pointer itself.
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
emit_op(result_type, id, to_unpacked_expression(rhs), false);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
// RHS expression is immutable, so just forward it.
// Copying these things really make no sense, but
// seems to be allowed anyways.
MSL: Don't dereference forwarded copies of `OpVariable` pointers. Fixes two more CTS tests under `dEQP-VK.spirv_assembly.instruction.compute.empty_struct.copying`.
2022-11-09 20:14:18 +00:00
auto &e = emit_op(result_type, id, to_expression(rhs), true, true);
Distinguish between cross edges and back edges. Handle the weird opcodes CopyMemory/CopyObject.
2016-11-18 08:59:54 +00:00
if (pointer)
{
auto *var = maybe_get_backing_variable(rhs);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
e.loaded_from = var ? var->self : ID(0);
Distinguish between cross edges and back edges. Handle the weird opcodes CopyMemory/CopyObject.
2016-11-18 08:59:54 +00:00
}
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
// If we're copying an access chain, need to inherit the read expressions.
auto *rhs_expr = maybe_get<SPIRExpression>(rhs);
if (rhs_expr)
Do not eagerly invalidate all active variables on a branch. This is not necessary, as we must emit an invalidating store before we potentially consume an invalid expression. In fact, we're a bit conservative here in this case for example: int tmp = variable; if (...) { variable = 10; } else { // Consuming tmp here is fine, but it was // invalidated while emitting other branch. // Technically, we need to study if there is an invalidating store // in the CFG between the loading block and this block, and the other // branch will not be a part of that analysis. int tmp2 = tmp * tmp; } Fixing this case means complex CFG traversal *everywhere*, and it feels like overkill. Fixing this exposed a bug with access chains, so fix a bug where expression dependencies were not inherited properly in access chains. Access chains are now considered forwarded if there is at least one dependency which is also forwarded.
2019-07-24 09:10:18 +00:00
{
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
e.implied_read_expressions = rhs_expr->implied_read_expressions;
Do not eagerly invalidate all active variables on a branch. This is not necessary, as we must emit an invalidating store before we potentially consume an invalid expression. In fact, we're a bit conservative here in this case for example: int tmp = variable; if (...) { variable = 10; } else { // Consuming tmp here is fine, but it was // invalidated while emitting other branch. // Technically, we need to study if there is an invalidating store // in the CFG between the loading block and this block, and the other // branch will not be a part of that analysis. int tmp2 = tmp * tmp; } Fixing this case means complex CFG traversal *everywhere*, and it feels like overkill. Fixing this exposed a bug with access chains, so fix a bug where expression dependencies were not inherited properly in access chains. Access chains are now considered forwarded if there is at least one dependency which is also forwarded.
2019-07-24 09:10:18 +00:00
e.expression_dependencies = rhs_expr->expression_dependencies;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
break;
}
case OpVectorShuffle:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t vec0 = ops[2];
uint32_t vec1 = ops[3];
const auto *elems = &ops[4];
length -= 4;
auto &type0 = expression_type(vec0);
Support -1 index in OpVectorShuffle. -1 (0xffffffff) literal means the component should be undefined. Since we cannot express undefined directly, just use a 0 literal in the appropriate type.
2019-03-25 09:17:05 +00:00
// If we have the undefined swizzle index -1, we need to swizzle in undefined data,
// or in our case, T(0).
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
bool shuffle = false;
for (uint32_t i = 0; i < length; i++)
Support -1 index in OpVectorShuffle. -1 (0xffffffff) literal means the component should be undefined. Since we cannot express undefined directly, just use a 0 literal in the appropriate type.
2019-03-25 09:17:05 +00:00
if (elems[i] >= type0.vecsize || elems[i] == 0xffffffffu)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
shuffle = true;
Deal with packed expressions in more scenarios. Make a new "to_extract_component_expression" helper.
2018-05-25 08:56:27 +00:00
// Cannot use swizzles with packed expressions, force shuffle path.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
if (!shuffle && has_extended_decoration(vec0, SPIRVCrossDecorationPhysicalTypePacked))
Deal with packed expressions in more scenarios. Make a new "to_extract_component_expression" helper.
2018-05-25 08:56:27 +00:00
shuffle = true;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string expr;
Add option to control use of temp vars for OpVectorShuffle.
2017-12-31 23:55:04 +00:00
bool should_fwd, trivial_forward;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (shuffle)
{
Handle exponential explosion of code-gen during first phase of compile. Certain patterns with OpVectorShuffle (and probably others) will cascade to so large, that they can cause OOM. After we have observed force_recompile, don't spend unnecessary memory emitting code which will never be used.
2018-01-15 09:26:12 +00:00
should_fwd = should_forward(vec0) && should_forward(vec1);
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
trivial_forward = should_suppress_usage_tracking(vec0) && should_suppress_usage_tracking(vec1);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Constructor style and shuffling from two different vectors.
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<string> args;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (uint32_t i = 0; i < length; i++)
{
Support -1 index in OpVectorShuffle. -1 (0xffffffff) literal means the component should be undefined. Since we cannot express undefined directly, just use a 0 literal in the appropriate type.
2019-03-25 09:17:05 +00:00
if (elems[i] == 0xffffffffu)
{
// Use a constant 0 here.
// We could use the first component or similar, but then we risk propagating
// a value we might not need, and bog down codegen.
SPIRConstant c;
c.constant_type = type0.parent_type;
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
assert(type0.parent_type != ID(0));
Support -1 index in OpVectorShuffle. -1 (0xffffffff) literal means the component should be undefined. Since we cannot express undefined directly, just use a 0 literal in the appropriate type.
2019-03-25 09:17:05 +00:00
args.push_back(constant_expression(c));
}
else if (elems[i] >= type0.vecsize)
Deal with packed expressions in more scenarios. Make a new "to_extract_component_expression" helper.
2018-05-25 08:56:27 +00:00
args.push_back(to_extract_component_expression(vec1, elems[i] - type0.vecsize));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Deal with packed expressions in more scenarios. Make a new "to_extract_component_expression" helper.
2018-05-25 08:56:27 +00:00
args.push_back(to_extract_component_expression(vec0, elems[i]));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
expr += join(type_to_glsl_constructor(get<SPIRType>(result_type)), "(", merge(args), ")");
}
else
{
Add option to control use of temp vars for OpVectorShuffle.
2017-12-31 23:55:04 +00:00
should_fwd = should_forward(vec0);
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
trivial_forward = should_suppress_usage_tracking(vec0);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// We only source from first vector, so can use swizzle.
CompilerMSL allow swizzle of packed_float3 vectors by unpacking to float3. Pass packed indicator back through OpAccessChain and OpLoad. Unpack packed vector before applying swizzle. Add packed swizzle test.
2018-01-05 22:46:56 +00:00
// If the vector is packed, unpack it before applying a swizzle (needed for MSL)
Unpack expressions when used in functions on MSL. OSX 10.14 broke (?) how overload resolution works, so overloading e.g. dot(float3, packed_float3) no longer works. Fix this by unpacking expressions before various func ops. This fix might need to be applied elsewhere, but do so later if needed.
2018-06-11 08:48:12 +00:00
expr += to_enclosed_unpacked_expression(vec0);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
expr += ".";
for (uint32_t i = 0; i < length; i++)
Support -1 index in OpVectorShuffle. -1 (0xffffffff) literal means the component should be undefined. Since we cannot express undefined directly, just use a 0 literal in the appropriate type.
2019-03-25 09:17:05 +00:00
{
assert(elems[i] != 0xffffffffu);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
expr += index_to_swizzle(elems[i]);
Support -1 index in OpVectorShuffle. -1 (0xffffffff) literal means the component should be undefined. Since we cannot express undefined directly, just use a 0 literal in the appropriate type.
2019-03-25 09:17:05 +00:00
}
CompilerMSL allow swizzle of packed_float3 vectors by unpacking to float3. Pass packed indicator back through OpAccessChain and OpLoad. Unpack packed vector before applying swizzle. Add packed swizzle test.
2018-01-05 22:46:56 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (backend.swizzle_is_function && length > 1)
expr += "()";
}
// A shuffle is trivial in that it doesn't actually *do* anything.
// We inherit the forwardedness from our arguments to avoid flushing out to temporaries when it's not really needed.
Add option to control use of temp vars for OpVectorShuffle.
2017-12-31 23:55:04 +00:00
emit_op(result_type, id, expr, should_fwd, trivial_forward);
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(id, vec0);
Do not disable temporary forwarding when we suppress usage tracking. This subtle bug removed any expression validation for trivially swizzled variables. Make usage suppression a more explicit concept rather than just hacking off forwarded_temporaries. There is some fallout here with loop generation since our expression invalidation is currently a bit too naive to handle loops properly. The forwarding bug masked this problem until now. If part of the loop condition is also used in the body, we end up reading an invalid expression, which in turn forces a temporary to be generated in the condition block, not good. We'll need to be smarter here ...
2019-07-23 17:14:13 +00:00
if (vec0 != vec1)
inherit_expression_dependencies(id, vec1);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
// ALU
case OpIsNan:
GLSL: Add support for modf, isnan and isinf in legacy GLSL
2023-01-19 10:57:37 +00:00
if (!is_legacy())
GLSL_UFOP(isnan);
else
{
// Check if the number doesn't equal itself
auto &type = get<SPIRType>(ops[0]);
if (type.vecsize > 1)
emit_binary_func_op(ops[0], ops[1], ops[2], ops[2], "notEqual");
else
emit_binary_op(ops[0], ops[1], ops[2], ops[2], "!=");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpIsInf:
GLSL: Add support for modf, isnan and isinf in legacy GLSL
2023-01-19 10:57:37 +00:00
if (!is_legacy())
GLSL_UFOP(isinf);
else
{
// inf * 2 == inf by IEEE 754 rules, note this also applies to 0.0
// This is more reliable than checking if product with zero is NaN
uint32_t result_type = ops[0];
uint32_t result_id = ops[1];
uint32_t operand = ops[2];
auto &type = get<SPIRType>(result_type);
std::string expr;
if (type.vecsize > 1)
{
expr = type_to_glsl_constructor(type);
expr += '(';
for (uint32_t i = 0; i < type.vecsize; i++)
{
auto comp = to_extract_component_expression(operand, i);
expr += join(comp, " != 0.0 && 2.0 * ", comp, " == ", comp);
if (i + 1 < type.vecsize)
expr += ", ";
}
expr += ')';
}
else
{
// Register an extra read to force writing out a temporary
auto oper = to_enclosed_expression(operand);
track_expression_read(operand);
expr += join(oper, " != 0.0 && 2.0 * ", oper, " == ", oper);
}
emit_op(result_type, result_id, expr, should_forward(operand));
inherit_expression_dependencies(result_id, operand);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpSNegate:
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
if (implicit_integer_promotion || expression_type_id(ops[2]) != ops[0])
GLSL_UOP_CAST(-);
else
GLSL_UOP(-);
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFNegate:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UOP(-);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpIAdd:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
// For simple arith ops, prefer the output type if there's a mismatch to avoid extra bitcasts.
auto type = get<SPIRType>(ops[0]).basetype;
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(+, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFAdd:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(+);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpISub:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
auto type = get<SPIRType>(ops[0]).basetype;
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(-, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFSub:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(-);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpIMul:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
auto type = get<SPIRType>(ops[0]).basetype;
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(*, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
}
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
case OpVectorTimesMatrix:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpMatrixTimesVector:
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
{
// If the matrix needs transpose, just flip the multiply order.
auto *e = maybe_get<SPIRExpression>(ops[opcode == OpMatrixTimesVector ? 2 : 3]);
if (e && e->need_transpose)
{
e->need_transpose = false;
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
string expr;
if (opcode == OpMatrixTimesVector)
Run format_all.sh.
2019-07-23 10:23:41 +00:00
expr = join(to_enclosed_unpacked_expression(ops[3]), " * ",
enclose_expression(to_unpacked_row_major_matrix_expression(ops[2])));
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
else
Run format_all.sh.
2019-07-23 10:23:41 +00:00
expr = join(enclose_expression(to_unpacked_row_major_matrix_expression(ops[3])), " * ",
to_enclosed_unpacked_expression(ops[2]));
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
bool forward = should_forward(ops[2]) && should_forward(ops[3]);
emit_op(ops[0], ops[1], expr, forward);
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
e->need_transpose = true;
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
inherit_expression_dependencies(ops[1], ops[2]);
inherit_expression_dependencies(ops[1], ops[3]);
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
}
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(*);
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
break;
}
Simplify row-major matrix/vector multiplies.
2019-07-23 08:56:57 +00:00
case OpMatrixTimesMatrix:
{
auto *a = maybe_get<SPIRExpression>(ops[2]);
auto *b = maybe_get<SPIRExpression>(ops[3]);
// If both matrices need transpose, we can multiply in flipped order and tag the expression as transposed.
// a^T * b^T = (b * a)^T.
if (a && b && a->need_transpose && b->need_transpose)
{
a->need_transpose = false;
b->need_transpose = false;
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
auto expr = join(enclose_expression(to_unpacked_row_major_matrix_expression(ops[3])), " * ",
enclose_expression(to_unpacked_row_major_matrix_expression(ops[2])));
bool forward = should_forward(ops[2]) && should_forward(ops[3]);
auto &e = emit_op(ops[0], ops[1], expr, forward);
e.need_transpose = true;
Simplify row-major matrix/vector multiplies.
2019-07-23 08:56:57 +00:00
a->need_transpose = true;
b->need_transpose = true;
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
inherit_expression_dependencies(ops[1], ops[2]);
inherit_expression_dependencies(ops[1], ops[3]);
Simplify row-major matrix/vector multiplies.
2019-07-23 08:56:57 +00:00
}
else
GLSL_BOP(*);
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpMatrixTimesScalar:
GLSL: Multiplying matrix with scalar shouldn't force transpose
2023-01-21 10:11:50 +00:00
{
auto *a = maybe_get<SPIRExpression>(ops[2]);
// If the matrix need transpose, just mark the result as needing so.
if (a && a->need_transpose)
{
a->need_transpose = false;
auto expr = join(enclose_expression(to_unpacked_row_major_matrix_expression(ops[2])), " * ",
to_enclosed_unpacked_expression(ops[3]));
bool forward = should_forward(ops[2]) && should_forward(ops[3]);
auto &e = emit_op(ops[0], ops[1], expr, forward);
e.need_transpose = true;
a->need_transpose = true;
inherit_expression_dependencies(ops[1], ops[2]);
inherit_expression_dependencies(ops[1], ops[3]);
}
else
GLSL_BOP(*);
break;
}
case OpFMul:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpVectorTimesScalar:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(*);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpOuterProduct:
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
if (options.version < 120) // Matches GLSL 1.10 / ESSL 1.00
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t a = ops[2];
uint32_t b = ops[3];
auto &type = get<SPIRType>(result_type);
string expr = type_to_glsl_constructor(type);
expr += "(";
for (uint32_t col = 0; col < type.columns; col++)
{
expr += to_enclosed_expression(a);
expr += " * ";
expr += to_extract_component_expression(b, col);
if (col + 1 < type.columns)
expr += ", ";
}
expr += ")";
emit_op(result_type, id, expr, should_forward(a) && should_forward(b));
inherit_expression_dependencies(id, a);
inherit_expression_dependencies(id, b);
}
else
GLSL_BFOP(outerProduct);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpDot:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP(dot);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpTranspose:
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
if (options.version < 120) // Matches GLSL 1.10 / ESSL 1.00
{
// transpose() is not available, so instead, flip need_transpose,
// which can later be turned into an emulated transpose op by
// convert_row_major_matrix(), if necessary.
uint32_t result_type = ops[0];
uint32_t result_id = ops[1];
uint32_t input = ops[2];
// Force need_transpose to false temporarily to prevent
// to_expression() from doing the transpose.
bool need_transpose = false;
auto *input_e = maybe_get<SPIRExpression>(input);
if (input_e)
swap(need_transpose, input_e->need_transpose);
bool forward = should_forward(input);
auto &e = emit_op(result_type, result_id, to_expression(input), forward);
e.need_transpose = !need_transpose;
// Restore the old need_transpose flag.
if (input_e)
input_e->need_transpose = need_transpose;
}
else
GLSL_UFOP(transpose);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
no expression type for OpSRem fix issue#582
2018-05-22 04:44:34 +00:00
case OpSRem:
handle OpSRem
2018-05-24 05:17:47 +00:00
{
uint32_t result_type = ops[0];
uint32_t result_id = ops[1];
uint32_t op0 = ops[2];
uint32_t op1 = ops[3];
Make SRem sign aware like all the other arithmetic ops.
2024-10-23 09:45:17 +00:00
auto &out_type = get<SPIRType>(result_type);
handle OpSRem
2018-05-24 05:17:47 +00:00
bool forward = should_forward(op0) && should_forward(op1);
Make SRem sign aware like all the other arithmetic ops.
2024-10-23 09:45:17 +00:00
string cast_op0, cast_op1;
auto expected_type = binary_op_bitcast_helper(cast_op0, cast_op1, int_type, op0, op1, false);
// Needs special handling.
auto expr = join(cast_op0, " - ", cast_op1, " * ", "(", cast_op0, " / ", cast_op1, ")");
handle OpSRem
2018-05-24 05:17:47 +00:00
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
if (implicit_integer_promotion)
Make SRem sign aware like all the other arithmetic ops.
2024-10-23 09:45:17 +00:00
{
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
expr = join(type_to_glsl(get<SPIRType>(result_type)), '(', expr, ')');
Make SRem sign aware like all the other arithmetic ops.
2024-10-23 09:45:17 +00:00
}
else if (out_type.basetype != int_type)
{
expected_type.basetype = int_type;
expr = join(bitcast_glsl_op(out_type, expected_type), '(', expr, ')');
}
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
handle OpSRem
2018-05-24 05:17:47 +00:00
emit_op(result_type, result_id, expr, forward);
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
no expression type for OpSRem fix issue#582
2018-05-22 04:44:34 +00:00
break;
handle OpSRem
2018-05-24 05:17:47 +00:00
}
no expression type for OpSRem fix issue#582
2018-05-22 04:44:34 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpSDiv:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BOP_CAST(/, int_type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpUDiv:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BOP_CAST(/, uint_type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
GLSL: Support extended arithmetic opcodes. - uaddCarry - usubBorrow - umulExtended - imulExtended
2018-11-13 13:50:17 +00:00
case OpIAddCarry:
case OpISubBorrow:
{
if (options.es && options.version < 310)
SPIRV_CROSS_THROW("Extended arithmetic is only available from ESSL 310.");
else if (!options.es && options.version < 400)
SPIRV_CROSS_THROW("Extended arithmetic is only available from GLSL 400.");
uint32_t result_type = ops[0];
uint32_t result_id = ops[1];
uint32_t op0 = ops[2];
uint32_t op1 = ops[3];
auto &type = get<SPIRType>(result_type);
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
emit_uninitialized_temporary_expression(result_type, result_id);
GLSL: Support extended arithmetic opcodes. - uaddCarry - usubBorrow - umulExtended - imulExtended
2018-11-13 13:50:17 +00:00
const char *op = opcode == OpIAddCarry ? "uaddCarry" : "usubBorrow";
statement(to_expression(result_id), ".", to_member_name(type, 0), " = ", op, "(", to_expression(op0), ", ",
to_expression(op1), ", ", to_expression(result_id), ".", to_member_name(type, 1), ");");
break;
}
case OpUMulExtended:
case OpSMulExtended:
{
if (options.es && options.version < 310)
SPIRV_CROSS_THROW("Extended arithmetic is only available from ESSL 310.");
else if (!options.es && options.version < 400)
SPIRV_CROSS_THROW("Extended arithmetic is only available from GLSL 4000.");
uint32_t result_type = ops[0];
uint32_t result_id = ops[1];
uint32_t op0 = ops[2];
uint32_t op1 = ops[3];
auto &type = get<SPIRType>(result_type);
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
emit_uninitialized_temporary_expression(result_type, result_id);
GLSL: Support extended arithmetic opcodes. - uaddCarry - usubBorrow - umulExtended - imulExtended
2018-11-13 13:50:17 +00:00
const char *op = opcode == OpUMulExtended ? "umulExtended" : "imulExtended";
statement(op, "(", to_expression(op0), ", ", to_expression(op1), ", ", to_expression(result_id), ".",
to_member_name(type, 1), ", ", to_expression(result_id), ".", to_member_name(type, 0), ");");
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFDiv:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(/);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpShiftRightLogical:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BOP_CAST(>>, uint_type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpShiftRightArithmetic:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BOP_CAST(>>, int_type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpShiftLeftLogical:
Don't need to force specific type for left shifts.
2016-05-13 13:30:40 +00:00
{
auto type = get<SPIRType>(ops[0]).basetype;
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(<<, type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Don't need to force specific type for left shifts.
2016-05-13 13:30:40 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpBitwiseOr:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
auto type = get<SPIRType>(ops[0]).basetype;
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(|, type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpBitwiseXor:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
auto type = get<SPIRType>(ops[0]).basetype;
Run format_all.sh.
2018-11-01 10:23:33 +00:00
GLSL_BOP_CAST(^, type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpBitwiseAnd:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
auto type = get<SPIRType>(ops[0]).basetype;
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(&, type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpNot:
MSL: Handle implicit integer promotion rules. MSL inherits the behavior of C where arithmetic on small types are implicitly converted to int. SPIR-V does not have this behavior, so make sure that arithmetic results are handled correctly.
2022-10-31 12:05:56 +00:00
if (implicit_integer_promotion || expression_type_id(ops[2]) != ops[0])
GLSL_UOP_CAST(~);
else
GLSL_UOP(~);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpUMod:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BOP_CAST(%, uint_type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpSMod:
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BOP_CAST(%, int_type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpFMod:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP(mod);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Implement FRem.
2018-02-15 12:31:29 +00:00
case OpFRem:
{
uint32_t result_type = ops[0];
uint32_t result_id = ops[1];
uint32_t op0 = ops[2];
uint32_t op1 = ops[3];
// Needs special handling.
bool forward = should_forward(op0) && should_forward(op1);
GLSL: Add support for modf, isnan and isinf in legacy GLSL
2023-01-19 10:57:37 +00:00
std::string expr;
if (!is_legacy())
{
expr = join(to_enclosed_expression(op0), " - ", to_enclosed_expression(op1), " * ", "trunc(",
to_enclosed_expression(op0), " / ", to_enclosed_expression(op1), ")");
}
else
{
// Legacy GLSL has no trunc, emulate by casting to int and back
auto &op0_type = expression_type(op0);
auto via_type = op0_type;
via_type.basetype = SPIRType::Int;
expr = join(to_enclosed_expression(op0), " - ", to_enclosed_expression(op1), " * ",
type_to_glsl(op0_type), "(", type_to_glsl(via_type), "(",
to_enclosed_expression(op0), " / ", to_enclosed_expression(op1), "))");
}
Implement FRem.
2018-02-15 12:31:29 +00:00
emit_op(result_type, result_id, expr, forward);
inherit_expression_dependencies(result_id, op0);
inherit_expression_dependencies(result_id, op1);
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Relational
case OpAny:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(any);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpAll:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(all);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpSelect:
emit_mix_op(ops[0], ops[1], ops[4], ops[3], ops[2]);
break;
case OpLogicalOr:
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
{
// No vector variant in GLSL for logical OR.
auto result_type = ops[0];
auto id = ops[1];
auto &type = get<SPIRType>(result_type);
if (type.vecsize > 1)
HLSL: Fix unrolled S/G LE/LT/GE/GT opcodes. Need to bitcast the unrolled expressions as well.
2019-10-14 14:08:39 +00:00
emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "||", false, SPIRType::Unknown);
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(||);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpLogicalAnd:
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
{
// No vector variant in GLSL for logical AND.
auto result_type = ops[0];
auto id = ops[1];
auto &type = get<SPIRType>(result_type);
if (type.vecsize > 1)
HLSL: Fix unrolled S/G LE/LT/GE/GT opcodes. Need to bitcast the unrolled expressions as well.
2019-10-14 14:08:39 +00:00
emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "&&", false, SPIRType::Unknown);
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(&&);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpLogicalNot:
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
{
auto &type = get<SPIRType>(ops[0]);
if (type.vecsize > 1)
Run format_all.sh.
2020-11-08 12:59:52 +00:00
GLSL_UFOP(not );
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UOP(!);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpIEqual:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
if (expression_type(ops[2]).vecsize > 1)
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BFOP_CAST(equal, int_type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
else
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BOP_CAST(==, int_type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
}
case OpLogicalEqual:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFOrdEqual:
{
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP(equal);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(==);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpINotEqual:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
if (expression_type(ops[2]).vecsize > 1)
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BFOP_CAST(notEqual, int_type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
else
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
GLSL_BOP_CAST(!=, int_type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
}
case OpLogicalNotEqual:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFOrdNotEqual:
Add relax_nan_checks options. Makes codegen from typical D3D emulation SPIR-V more readable. Also makes cross compilation with NotEqual more sensible. It's very rare to actually need the strict NaN-checks in practice. Also, glslang now emits UnordNotEqual by default it seems, so give up trying to assume OrdNotEqual. Harmonize for UnordNotEqual as the sane default.
2022-03-03 10:04:45 +00:00
case OpFUnordNotEqual:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Add relax_nan_checks options. Makes codegen from typical D3D emulation SPIR-V more readable. Also makes cross compilation with NotEqual more sensible. It's very rare to actually need the strict NaN-checks in practice. Also, glslang now emits UnordNotEqual by default it seems, so give up trying to assume OrdNotEqual. Harmonize for UnordNotEqual as the sane default.
2022-03-03 10:04:45 +00:00
// GLSL is fuzzy on what to do with ordered vs unordered not equal.
// glslang started emitting UnorderedNotEqual some time ago to harmonize with IEEE,
// but this means we have no easy way of implementing ordered not equal.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP(notEqual);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(!=);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpUGreaterThan:
case OpSGreaterThan:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
GLSL: Deal correctly with bitwidth on integer compares.
2019-10-14 13:23:38 +00:00
auto type = opcode == OpUGreaterThan ? uint_type : int_type;
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP_CAST(greaterThan, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(>, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFOrdGreaterThan:
{
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP(greaterThan);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(>);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpUGreaterThanEqual:
case OpSGreaterThanEqual:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
GLSL: Deal correctly with bitwidth on integer compares.
2019-10-14 13:23:38 +00:00
auto type = opcode == OpUGreaterThanEqual ? uint_type : int_type;
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP_CAST(greaterThanEqual, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(>=, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFOrdGreaterThanEqual:
{
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP(greaterThanEqual);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(>=);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpULessThan:
case OpSLessThan:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
GLSL: Deal correctly with bitwidth on integer compares.
2019-10-14 13:23:38 +00:00
auto type = opcode == OpULessThan ? uint_type : int_type;
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP_CAST(lessThan, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(<, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFOrdLessThan:
{
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP(lessThan);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(<);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpULessThanEqual:
case OpSLessThanEqual:
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
{
GLSL: Deal correctly with bitwidth on integer compares.
2019-10-14 13:23:38 +00:00
auto type = opcode == OpULessThanEqual ? uint_type : int_type;
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP_CAST(lessThanEqual, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP_CAST(<=, type);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFOrdLessThanEqual:
{
if (expression_type(ops[2]).vecsize > 1)
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BFOP(lessThanEqual);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_BOP(<=);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
// Conversion
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
case OpSConvert:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpConvertSToF:
case OpUConvert:
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
case OpConvertUToF:
{
auto input_type = opcode == OpSConvert || opcode == OpConvertSToF ? int_type : uint_type;
uint32_t result_type = ops[0];
uint32_t id = ops[1];
auto &type = get<SPIRType>(result_type);
auto &arg_type = expression_type(ops[2]);
auto func = type_to_glsl_constructor(type);
Fix sign handling for S/UToF.
2019-11-28 12:49:53 +00:00
if (arg_type.width < type.width || type_is_floating_point(type))
Deal with mismatched signs in S/U/F conversion opcodes.
2019-04-10 09:33:52 +00:00
emit_unary_func_op_cast(result_type, id, ops[2], func.c_str(), input_type, type.basetype);
else
emit_unary_func_op(result_type, id, ops[2], func.c_str());
break;
}
case OpConvertFToU:
case OpConvertFToS:
{
// Cast to expected arithmetic type, then potentially bitcast away to desired signedness.
uint32_t result_type = ops[0];
uint32_t id = ops[1];
auto &type = get<SPIRType>(result_type);
auto expected_type = type;
auto &float_type = expression_type(ops[2]);
expected_type.basetype =
opcode == OpConvertFToS ? to_signed_basetype(type.width) : to_unsigned_basetype(type.width);
auto func = type_to_glsl_constructor(expected_type);
emit_unary_func_op_cast(result_type, id, ops[2], func.c_str(), float_type.basetype, expected_type.basetype);
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFConvert:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
auto func = type_to_glsl_constructor(get<SPIRType>(result_type));
emit_unary_func_op(result_type, id, ops[2], func.c_str());
break;
}
case OpBitcast:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t arg = ops[2];
GLSL: Support f16x2 <-> f32 bitcast. There is no native formulation, so introduce a concept of a "complex" bitcast to handle odd-ball cases which have no native unary operation.
2020-04-21 21:27:33 +00:00
if (!emit_complex_bitcast(result_type, id, arg))
{
auto op = bitcast_glsl_op(get<SPIRType>(result_type), expression_type(arg));
emit_unary_func_op(result_type, id, arg, op.c_str());
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
Add support for OpQuantizeF16.
2016-05-31 14:56:15 +00:00
case OpQuantizeToF16:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t arg = ops[2];
string op;
auto &type = get<SPIRType>(result_type);
switch (type.vecsize)
{
case 1:
op = join("unpackHalf2x16(packHalf2x16(vec2(", to_expression(arg), "))).x");
break;
case 2:
op = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), "))");
break;
case 3:
{
auto op0 = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), ".xy))");
auto op1 = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), ".zz)).x");
op = join("vec3(", op0, ", ", op1, ")");
break;
}
case 4:
{
auto op0 = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), ".xy))");
auto op1 = join("unpackHalf2x16(packHalf2x16(", to_expression(arg), ".zw))");
op = join("vec4(", op0, ", ", op1, ")");
break;
}
default:
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Illegal argument to OpQuantizeToF16.");
Add support for OpQuantizeF16.
2016-05-31 14:56:15 +00:00
}
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
emit_op(result_type, id, op, should_forward(arg));
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(id, arg);
Add support for OpQuantizeF16.
2016-05-31 14:56:15 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Derivatives
case OpDPdx:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(dFdx);
Legacy GLES extensions.
2016-09-17 12:33:16 +00:00
if (is_legacy_es())
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_OES_standard_derivatives");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpDPdy:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(dFdy);
Legacy GLES extensions.
2016-09-17 12:33:16 +00:00
if (is_legacy_es())
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_OES_standard_derivatives");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Add dFd(x/y)(Fine/Coarse) to GLSL
2017-03-24 12:59:19 +00:00
case OpDPdxFine:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(dFdxFine);
Handle GL_ARB_derivative_control
2017-03-24 14:58:54 +00:00
if (options.es)
{
SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES.");
}
if (options.version < 450)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_derivative_control");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add dFd(x/y)(Fine/Coarse) to GLSL
2017-03-24 12:59:19 +00:00
break;
case OpDPdyFine:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(dFdyFine);
Handle GL_ARB_derivative_control
2017-03-24 14:58:54 +00:00
if (options.es)
{
SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES.");
}
if (options.version < 450)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_derivative_control");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add dFd(x/y)(Fine/Coarse) to GLSL
2017-03-24 12:59:19 +00:00
break;
case OpDPdxCoarse:
Handle GL_ARB_derivative_control
2017-03-24 14:58:54 +00:00
if (options.es)
{
SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES.");
}
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(dFdxCoarse);
Handle GL_ARB_derivative_control
2017-03-24 14:58:54 +00:00
if (options.version < 450)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_derivative_control");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add dFd(x/y)(Fine/Coarse) to GLSL
2017-03-24 12:59:19 +00:00
break;
case OpDPdyCoarse:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(dFdyCoarse);
Handle GL_ARB_derivative_control
2017-03-24 14:58:54 +00:00
if (options.es)
{
SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES.");
}
if (options.version < 450)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_derivative_control");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add dFd(x/y)(Fine/Coarse) to GLSL
2017-03-24 12:59:19 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpFwidth:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(fwidth);
Legacy GLES extensions.
2016-09-17 12:33:16 +00:00
if (is_legacy_es())
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_OES_standard_derivatives");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Add test shader for FP16 support.
2018-03-06 15:28:42 +00:00
case OpFwidthCoarse:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(fwidthCoarse);
Add test shader for FP16 support.
2018-03-06 15:28:42 +00:00
if (options.es)
{
SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES.");
}
if (options.version < 450)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_derivative_control");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add test shader for FP16 support.
2018-03-06 15:28:42 +00:00
break;
case OpFwidthFine:
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(fwidthFine);
Add test shader for FP16 support.
2018-03-06 15:28:42 +00:00
if (options.es)
{
SPIRV_CROSS_THROW("GL_ARB_derivative_control is unavailable in OpenGL ES.");
}
if (options.version < 450)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_derivative_control");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add test shader for FP16 support.
2018-03-06 15:28:42 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Bitfield
case OpBitFieldInsert:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
{
Run format_all.sh.
2019-08-28 12:25:26 +00:00
emit_bitfield_insert_op(ops[0], ops[1], ops[2], ops[3], ops[4], ops[5], "bitfieldInsert", SPIRType::Int);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpBitFieldSExtract:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
{
Run format_all.sh.
2019-08-28 12:25:26 +00:00
emit_trinary_func_op_bitextract(ops[0], ops[1], ops[2], ops[3], ops[4], "bitfieldExtract", int_type, int_type,
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
SPIRType::Int, SPIRType::Int);
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpBitFieldUExtract:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
{
Run format_all.sh.
2019-08-28 12:25:26 +00:00
emit_trinary_func_op_bitextract(ops[0], ops[1], ops[2], ops[3], ops[4], "bitfieldExtract", uint_type, uint_type,
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
SPIRType::Int, SPIRType::Int);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpBitReverse:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
// BitReverse does not have issues with sign since result type must match input type.
Add basic namespace to internal macros. Some projects build SPIRV-Cross as a single translation unit and this causes a lot of warnings because the same macro is redeclared multiple times in the different backends. This make sure that each backend has its own namespace for internal macros.
2018-06-28 20:57:52 +00:00
GLSL_UFOP(bitfieldReverse);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpBitCount:
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
{
auto basetype = expression_type(ops[2]).basetype;
emit_unary_func_op_cast(ops[0], ops[1], ops[2], "bitCount", basetype, int_type);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Deal correctly with sign on bitfield operations. Need a lot of special purpose implementation functions for these.
2019-08-26 09:01:14 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Atomics
case OpAtomicExchange:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t ptr = ops[2];
// Ignore semantics for now, probably only relevant to CL.
uint32_t val = ops[5];
const char *op = check_atomic_image(ptr) ? "imageAtomicExchange" : "atomicExchange";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_atomic_func_op(result_type, id, ptr, val, op);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpAtomicCompareExchange:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
uint32_t ptr = ops[2];
uint32_t val = ops[6];
uint32_t comp = ops[7];
const char *op = check_atomic_image(ptr) ? "imageAtomicCompSwap" : "atomicCompSwap";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_atomic_func_op(result_type, id, ptr, comp, val, op);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpAtomicLoad:
Implement OpAtomicLoad/OpAtomicStore. Need some emulation on GLSL/HLSL, fix bug with atomic store on MSL.
2020-04-27 10:09:59 +00:00
{
// In plain GLSL, we have no atomic loads, so emulate this by fetch adding by 0 and hope compiler figures it out.
// Alternatively, we could rely on KHR_memory_model, but that's not very helpful for GL.
auto &type = expression_type(ops[2]);
Fix infinite loop when OpAtomic* temporaries are used in other blocks. We made the mistake of registering a dependency on the atomic variable even if the atomic result was forced to a temporary. There is no need to register reads from atomic variables like this as we always force atomic results to a temporary and argument read/writes do not need to be tracked.
2019-04-24 07:31:44 +00:00
forced_temporaries.insert(ops[1]);
Implement OpAtomicLoad/OpAtomicStore. Need some emulation on GLSL/HLSL, fix bug with atomic store on MSL.
2020-04-27 10:09:59 +00:00
bool atomic_image = check_atomic_image(ops[2]);
bool unsigned_type = (type.basetype == SPIRType::UInt) ||
(atomic_image && get<SPIRType>(type.image.type).basetype == SPIRType::UInt);
const char *op = atomic_image ? "imageAtomicAdd" : "atomicAdd";
const char *increment = unsigned_type ? "0u" : "0";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_op(ops[0], ops[1],
join(op, "(",
to_non_uniform_aware_expression(ops[2]), ", ", increment, ")"), false);
Implement OpAtomicLoad/OpAtomicStore. Need some emulation on GLSL/HLSL, fix bug with atomic store on MSL.
2020-04-27 10:09:59 +00:00
flush_all_atomic_capable_variables();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Implement OpAtomicLoad/OpAtomicStore. Need some emulation on GLSL/HLSL, fix bug with atomic store on MSL.
2020-04-27 10:09:59 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Formatting.
2018-01-09 11:51:21 +00:00
case OpAtomicStore:
Implement OpAtomicLoad/OpAtomicStore. Need some emulation on GLSL/HLSL, fix bug with atomic store on MSL.
2020-04-27 10:09:59 +00:00
{
// In plain GLSL, we have no atomic stores, so emulate this with an atomic exchange where we don't consume the result.
// Alternatively, we could rely on KHR_memory_model, but that's not very helpful for GL.
uint32_t ptr = ops[0];
// Ignore semantics for now, probably only relevant to CL.
uint32_t val = ops[3];
const char *op = check_atomic_image(ptr) ? "imageAtomicExchange" : "atomicExchange";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
statement(op, "(", to_non_uniform_aware_expression(ptr), ", ", to_expression(val), ");");
Implement OpAtomicLoad/OpAtomicStore. Need some emulation on GLSL/HLSL, fix bug with atomic store on MSL.
2020-04-27 10:09:59 +00:00
flush_all_atomic_capable_variables();
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpAtomicIIncrement:
case OpAtomicIDecrement:
Implement atomic increment/decrement in GLSL and HLSL.
2018-09-17 13:46:39 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
forced_temporaries.insert(ops[1]);
Implement atomic increment/decrement in GLSL and HLSL.
2018-09-17 13:46:39 +00:00
auto &type = expression_type(ops[2]);
if (type.storage == StorageClassAtomicCounter)
{
// Legacy GLSL stuff, not sure if this is relevant to support.
if (opcode == OpAtomicIIncrement)
GLSL_UFOP(atomicCounterIncrement);
else
GLSL_UFOP(atomicCounterDecrement);
}
else
{
bool atomic_image = check_atomic_image(ops[2]);
bool unsigned_type = (type.basetype == SPIRType::UInt) ||
(atomic_image && get<SPIRType>(type.image.type).basetype == SPIRType::UInt);
const char *op = atomic_image ? "imageAtomicAdd" : "atomicAdd";
const char *increment = nullptr;
if (opcode == OpAtomicIIncrement && unsigned_type)
increment = "1u";
else if (opcode == OpAtomicIIncrement)
increment = "1";
else if (unsigned_type)
increment = "uint(-1)";
else
increment = "-1";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_op(ops[0], ops[1],
join(op, "(", to_non_uniform_aware_expression(ops[2]), ", ", increment, ")"), false);
Implement atomic increment/decrement in GLSL and HLSL.
2018-09-17 13:46:39 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
flush_all_atomic_capable_variables();
break;
Implement atomic increment/decrement in GLSL and HLSL.
2018-09-17 13:46:39 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpAtomicIAdd:
GLSL: Add basic support for GL_EXT_shader_atomic_float.
2022-05-27 10:12:50 +00:00
case OpAtomicFAddEXT:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicAdd" : "atomicAdd";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_atomic_func_op(ops[0], ops[1], ops[2], ops[5], op);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpAtomicISub:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicAdd" : "atomicAdd";
forced_temporaries.insert(ops[1]);
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
auto expr = join(op, "(", to_non_uniform_aware_expression(ops[2]), ", -", to_enclosed_expression(ops[5]), ")");
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
emit_op(ops[0], ops[1], expr, should_forward(ops[2]) && should_forward(ops[5]));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
flush_all_atomic_capable_variables();
break;
}
case OpAtomicSMin:
case OpAtomicUMin:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicMin" : "atomicMin";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_atomic_func_op(ops[0], ops[1], ops[2], ops[5], op);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpAtomicSMax:
case OpAtomicUMax:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicMax" : "atomicMax";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_atomic_func_op(ops[0], ops[1], ops[2], ops[5], op);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpAtomicAnd:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicAnd" : "atomicAnd";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_atomic_func_op(ops[0], ops[1], ops[2], ops[5], op);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpAtomicOr:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicOr" : "atomicOr";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_atomic_func_op(ops[0], ops[1], ops[2], ops[5], op);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpAtomicXor:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicXor" : "atomicXor";
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
emit_atomic_func_op(ops[0], ops[1], ops[2], ops[5], op);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
// Geometry shaders
case OpEmitVertex:
statement("EmitVertex();");
break;
case OpEndPrimitive:
statement("EndPrimitive();");
break;
case OpEmitStreamVertex:
GLSL: Fix EmitStreamVertex/Primitive.
2019-12-09 09:45:44 +00:00
{
if (options.es)
SPIRV_CROSS_THROW("Multi-stream geometry shaders not supported in ES.");
else if (!options.es && options.version < 400)
SPIRV_CROSS_THROW("Multi-stream geometry shaders only supported in GLSL 400.");
auto stream_expr = to_expression(ops[0]);
if (expression_type(ops[0]).basetype != SPIRType::Int)
stream_expr = join("int(", stream_expr, ")");
statement("EmitStreamVertex(", stream_expr, ");");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
GLSL: Fix EmitStreamVertex/Primitive.
2019-12-09 09:45:44 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpEndStreamPrimitive:
GLSL: Fix EmitStreamVertex/Primitive.
2019-12-09 09:45:44 +00:00
{
if (options.es)
SPIRV_CROSS_THROW("Multi-stream geometry shaders not supported in ES.");
else if (!options.es && options.version < 400)
SPIRV_CROSS_THROW("Multi-stream geometry shaders only supported in GLSL 400.");
auto stream_expr = to_expression(ops[0]);
if (expression_type(ops[0]).basetype != SPIRType::Int)
stream_expr = join("int(", stream_expr, ")");
statement("EndStreamPrimitive(", stream_expr, ");");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
GLSL: Fix EmitStreamVertex/Primitive.
2019-12-09 09:45:44 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Textures
case OpImageSampleExplicitLod:
case OpImageSampleProjExplicitLod:
case OpImageSampleDrefExplicitLod:
case OpImageSampleProjDrefExplicitLod:
Legacy GLES extensions.
2016-09-17 12:33:16 +00:00
case OpImageSampleImplicitLod:
case OpImageSampleProjImplicitLod:
case OpImageSampleDrefImplicitLod:
case OpImageSampleProjDrefImplicitLod:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case OpImageFetch:
case OpImageGather:
case OpImageDrefGather:
// Gets a bit hairy, so move this to a separate instruction.
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
emit_texture_op(instruction, false);
break;
case OpImageSparseSampleExplicitLod:
case OpImageSparseSampleProjExplicitLod:
case OpImageSparseSampleDrefExplicitLod:
case OpImageSparseSampleProjDrefExplicitLod:
case OpImageSparseSampleImplicitLod:
case OpImageSparseSampleProjImplicitLod:
case OpImageSparseSampleDrefImplicitLod:
case OpImageSparseSampleProjDrefImplicitLod:
case OpImageSparseFetch:
case OpImageSparseGather:
case OpImageSparseDrefGather:
// Gets a bit hairy, so move this to a separate instruction.
emit_texture_op(instruction, true);
break;
case OpImageSparseTexelsResident:
if (options.es)
SPIRV_CROSS_THROW("Sparse feedback is not supported in GLSL.");
require_extension_internal("GL_ARB_sparse_texture2");
GLSL: Support uint code for sparse residency query.
2020-06-08 09:40:02 +00:00
emit_unary_func_op_cast(ops[0], ops[1], ops[2], "sparseTexelsResidentARB", int_type, SPIRType::Boolean);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case OpImage:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Fix usage tracking issue for OpImage.
2018-04-27 09:10:10 +00:00
// Suppress usage tracking.
auto &e = emit_op(result_type, id, to_expression(ops[2]), true, true);
Implement OpImageQuerySamples.
2016-07-11 10:47:46 +00:00
// When using the image, we need to know which variable it is actually loaded from.
auto *var = maybe_get_backing_variable(ops[2]);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
e.loaded_from = var ? var->self : ID(0);
Implement OpImageQuerySamples.
2016-07-11 10:47:46 +00:00
break;
}
Add support for OpImageQueryLod.
2016-07-19 07:22:54 +00:00
case OpImageQueryLod:
{
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
const char *op = nullptr;
Add support for OpImageQueryLod.
2016-07-19 07:22:54 +00:00
if (!options.es && options.version < 400)
{
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_texture_query_lod");
Add support for OpImageQueryLod.
2016-07-19 07:22:54 +00:00
// For some reason, the ARB spec is all-caps.
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
op = "textureQueryLOD";
Add support for OpImageQueryLod.
2016-07-19 07:22:54 +00:00
}
else if (options.es)
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
{
if (options.version < 300)
SPIRV_CROSS_THROW("textureQueryLod not supported in legacy ES");
require_extension_internal("GL_EXT_texture_query_lod");
op = "textureQueryLOD";
}
Add support for OpImageQueryLod.
2016-07-19 07:22:54 +00:00
else
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
op = "textureQueryLod";
auto sampler_expr = to_expression(ops[2]);
if (has_decoration(ops[2], DecorationNonUniform))
{
if (maybe_get_backing_variable(ops[2]))
convert_non_uniform_expression(sampler_expr, ops[2]);
else if (*backend.nonuniform_qualifier != '\0')
sampler_expr = join(backend.nonuniform_qualifier, "(", sampler_expr, ")");
}
bool forward = should_forward(ops[3]);
emit_op(ops[0], ops[1],
join(op, "(", sampler_expr, ", ", to_unpacked_expression(ops[3]), ")"),
forward);
inherit_expression_dependencies(ops[1], ops[2]);
inherit_expression_dependencies(ops[1], ops[3]);
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for OpImageQueryLod.
2016-07-19 07:22:54 +00:00
break;
}
Implement OpImageQueryLevels.
2016-07-19 07:28:32 +00:00
case OpImageQueryLevels:
{
Add exhaustive image query to HLSL. Need to strip this down somehow ...
2017-09-20 07:59:32 +00:00
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Implement OpImageQueryLevels.
2016-07-19 07:28:32 +00:00
if (!options.es && options.version < 430)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_texture_query_levels");
Implement OpImageQueryLevels.
2016-07-19 07:28:32 +00:00
if (options.es)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("textureQueryLevels not supported in ES profile.");
Add exhaustive image query to HLSL. Need to strip this down somehow ...
2017-09-20 07:59:32 +00:00
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
auto expr = join("textureQueryLevels(", convert_separate_image_to_expression(ops[2]), ")");
Add exhaustive image query to HLSL. Need to strip this down somehow ...
2017-09-20 07:59:32 +00:00
auto &restype = get<SPIRType>(ops[0]);
expr = bitcast_expression(restype, SPIRType::Int, expr);
emit_op(result_type, id, expr, true);
Implement OpImageQueryLevels.
2016-07-19 07:28:32 +00:00
break;
}
Implement OpImageQuerySamples.
2016-07-11 10:47:46 +00:00
case OpImageQuerySamples:
{
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
auto &type = expression_type(ops[2]);
uint32_t result_type = ops[0];
uint32_t id = ops[1];
Implement OpImageQuerySamples.
2016-07-11 10:47:46 +00:00
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
if (options.es)
SPIRV_CROSS_THROW("textureSamples and imageSamples not supported in ES profile.");
else if (options.version < 450)
require_extension_internal("GL_ARB_texture_query_samples");
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
string expr;
if (type.image.sampled == 2)
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
expr = join("imageSamples(", to_non_uniform_aware_expression(ops[2]), ")");
Implement OpImageQuerySamples.
2016-07-11 10:47:46 +00:00
else
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
expr = join("textureSamples(", convert_separate_image_to_expression(ops[2]), ")");
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
auto &restype = get<SPIRType>(ops[0]);
expr = bitcast_expression(restype, SPIRType::Int, expr);
emit_op(result_type, id, expr, true);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpSampledImage:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
emit_sampled_image_op(result_type, id, ops[2], ops[3]);
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
inherit_expression_dependencies(id, ops[2]);
inherit_expression_dependencies(id, ops[3]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpImageQuerySizeLod:
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
GLSL: Legacy / extension fallbacks for textureSize and texelFetch
2020-11-09 14:26:46 +00:00
uint32_t img = ops[2];
GLSL: Account for ES sampler1D to sampler2D promotion in textureSize.
2022-09-15 18:33:09 +00:00
auto &type = expression_type(img);
auto &imgtype = get<SPIRType>(type.self);
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
GLSL: Legacy / extension fallbacks for textureSize and texelFetch
2020-11-09 14:26:46 +00:00
std::string fname = "textureSize";
if (is_legacy_desktop())
{
fname = legacy_tex_op(fname, imgtype, img);
}
else if (is_legacy_es())
SPIRV_CROSS_THROW("textureSize is not supported in ESSL 100.");
auto expr = join(fname, "(", convert_separate_image_to_expression(img), ", ",
Run format_all.sh.
2018-04-30 10:46:21 +00:00
bitcast_expression(SPIRType::Int, ops[3]), ")");
GLSL: Account for ES sampler1D to sampler2D promotion in textureSize.
2022-09-15 18:33:09 +00:00
// ES needs to emulate 1D images as 2D.
if (type.image.dim == Dim1D && options.es)
expr = join(expr, ".x");
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
auto &restype = get<SPIRType>(ops[0]);
expr = bitcast_expression(restype, SPIRType::Int, expr);
emit_op(result_type, id, expr, true);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Image load/store
case OpImageRead:
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
case OpImageSparseRead:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
// We added Nonreadable speculatively to the OpImage variable due to glslangValidator
// not adding the proper qualifiers.
// If it turns out we need to read the image after all, remove the qualifier and recompile.
auto *var = maybe_get_backing_variable(ops[2]);
if (var)
{
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
auto &flags = get_decoration_bitset(var->self);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationNonReadable))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
unset_decoration(var->self, DecorationNonReadable);
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
uint32_t result_type = ops[0];
uint32_t id = ops[1];
bool pure;
string imgexpr;
auto &type = expression_type(ops[2]);
Add support for generic remapping of variables.
2016-07-06 09:04:06 +00:00
if (var && var->remapped_variable) // Remapped input, just read as-is without any op-code
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
if (type.image.ms)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Trying to remap multisampled image to variable, this is not possible.");
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
Non-functional: Update formatting.
2016-05-23 11:30:02 +00:00
auto itr =
find_if(begin(pls_inputs), end(pls_inputs), [var](const PlsRemap &pls) { return pls.id == var->self; });
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (itr == end(pls_inputs))
Add support for generic remapping of variables.
2016-07-06 09:04:06 +00:00
{
// For non-PLS inputs, we rely on subpass type remapping information to get it right
// since ImageRead always returns 4-component vectors and the backing type is opaque.
if (!var->remapped_components)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("subpassInput was remapped, but remap_components is not set correctly.");
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
imgexpr = remap_swizzle(get<SPIRType>(result_type), var->remapped_components, to_expression(ops[2]));
Add support for generic remapping of variables.
2016-07-06 09:04:06 +00:00
}
else
{
// PLS input could have different number of components than what the SPIR expects, swizzle to
// the appropriate vector size.
uint32_t components = pls_format_to_components(itr->format);
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
imgexpr = remap_swizzle(get<SPIRType>(result_type), components, to_expression(ops[2]));
Add support for generic remapping of variables.
2016-07-06 09:04:06 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
pure = true;
}
else if (type.image.dim == DimSubpassData)
{
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
if (var && subpass_input_is_framebuffer_fetch(var->self))
{
imgexpr = to_expression(var->self);
}
else if (options.vulkan_semantics)
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
{
// With Vulkan semantics, use the proper Vulkan GLSL construct.
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
if (type.image.ms)
{
uint32_t operands = ops[4];
if (operands != ImageOperandsSampleMask || length != 6)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Multisampled image used in OpImageRead, but unexpected "
"operand mask was used.");
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
uint32_t samples = ops[5];
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
imgexpr = join("subpassLoad(", to_non_uniform_aware_expression(ops[2]), ", ", to_expression(samples), ")");
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
}
else
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
imgexpr = join("subpassLoad(", to_non_uniform_aware_expression(ops[2]), ")");
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
}
else
{
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
if (type.image.ms)
{
uint32_t operands = ops[4];
if (operands != ImageOperandsSampleMask || length != 6)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Multisampled image used in OpImageRead, but unexpected "
"operand mask was used.");
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
uint32_t samples = ops[5];
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
imgexpr = join("texelFetch(", to_non_uniform_aware_expression(ops[2]), ", ivec2(gl_FragCoord.xy), ",
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
to_expression(samples), ")");
}
else
{
// Implement subpass loads via texture barrier style sampling.
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
imgexpr = join("texelFetch(", to_non_uniform_aware_expression(ops[2]), ", ivec2(gl_FragCoord.xy), 0)");
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
}
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
}
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
imgexpr = remap_swizzle(get<SPIRType>(result_type), 4, imgexpr);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
pure = true;
}
else
{
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
bool sparse = opcode == OpImageSparseRead;
uint32_t sparse_code_id = 0;
uint32_t sparse_texel_id = 0;
if (sparse)
emit_sparse_feedback_temporaries(ops[0], ops[1], sparse_code_id, sparse_texel_id);
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
// imageLoad only accepts int coords, not uint.
auto coord_expr = to_expression(ops[3]);
auto target_coord_type = expression_type(ops[3]);
target_coord_type.basetype = SPIRType::Int;
coord_expr = bitcast_expression(target_coord_type, expression_type(ops[3]).basetype, coord_expr);
GLSL: Implement 1D texture emulation for ES. ES does not support 1D images at all. Fake it by promoting 1D images to 2D.
2022-05-27 09:51:34 +00:00
// ES needs to emulate 1D images as 2D.
if (type.image.dim == Dim1D && options.es)
coord_expr = join("ivec2(", coord_expr, ", 0)");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Plain image load/store.
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
if (sparse)
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
{
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
if (type.image.ms)
{
uint32_t operands = ops[4];
if (operands != ImageOperandsSampleMask || length != 6)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Multisampled image used in OpImageRead, but unexpected "
"operand mask was used.");
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
uint32_t samples = ops[5];
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
statement(to_expression(sparse_code_id), " = sparseImageLoadARB(", to_non_uniform_aware_expression(ops[2]), ", ",
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
coord_expr, ", ", to_expression(samples), ", ", to_expression(sparse_texel_id), ");");
}
else
{
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
statement(to_expression(sparse_code_id), " = sparseImageLoadARB(", to_non_uniform_aware_expression(ops[2]), ", ",
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
coord_expr, ", ", to_expression(sparse_texel_id), ");");
}
Run format_all.sh.
2020-07-01 09:42:58 +00:00
imgexpr = join(type_to_glsl(get<SPIRType>(result_type)), "(", to_expression(sparse_code_id), ", ",
to_expression(sparse_texel_id), ")");
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
}
else
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
{
if (type.image.ms)
{
uint32_t operands = ops[4];
if (operands != ImageOperandsSampleMask || length != 6)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Multisampled image used in OpImageRead, but unexpected "
"operand mask was used.");
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
uint32_t samples = ops[5];
imgexpr =
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
join("imageLoad(", to_non_uniform_aware_expression(ops[2]), ", ", coord_expr, ", ", to_expression(samples), ")");
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
}
else
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
imgexpr = join("imageLoad(", to_non_uniform_aware_expression(ops[2]), ", ", coord_expr, ")");
GLSL: Implement sparse feedback.
2020-06-04 13:50:28 +00:00
}
if (!sparse)
imgexpr = remap_swizzle(get<SPIRType>(result_type), 4, imgexpr);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
pure = false;
}
Remove forwardable bit in SPIRVariable. Was never really used for anything. It's always true.
2022-03-04 10:05:21 +00:00
if (var)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Check forwarding in OpImageRead.
2017-11-22 10:28:58 +00:00
bool forward = forced_temporaries.find(id) == end(forced_temporaries);
auto &e = emit_op(result_type, id, imgexpr, forward);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// We only need to track dependencies if we're reading from image load/store.
if (!pure)
{
e.loaded_from = var->self;
Check forwarding in OpImageRead.
2017-11-22 10:28:58 +00:00
if (forward)
var->dependees.push_back(id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
else
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
emit_op(result_type, id, imgexpr, false);
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(id, ops[2]);
if (type.image.ms)
inherit_expression_dependencies(id, ops[5]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpImageTexelPointer:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
OpImageTexelPointer needs to use an int coordinate type for GLSL, but not for MSL.
2019-08-26 15:28:13 +00:00
auto coord_expr = to_expression(ops[3]);
auto target_coord_type = expression_type(ops[3]);
target_coord_type.basetype = SPIRType::Int;
coord_expr = bitcast_expression(target_coord_type, expression_type(ops[3]).basetype, coord_expr);
GLSL/HLSL: Implement nonuniform qualifier for image atomics.
2020-03-19 10:35:06 +00:00
auto expr = join(to_expression(ops[2]), ", ", coord_expr);
auto &e = set<SPIRExpression>(id, expr, result_type, true);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Implement OpImageQuerySamples.
2016-07-11 10:47:46 +00:00
// When using the pointer, we need to know which variable it is actually loaded from.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto *var = maybe_get_backing_variable(ops[2]);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
e.loaded_from = var ? var->self : ID(0);
MSL: Minor cleanups for texture atomic emulation. Storing pointers to internal objects is generally not done, IDs are preferred.
2019-10-24 09:30:20 +00:00
inherit_expression_dependencies(id, ops[3]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpImageWrite:
{
// We added Nonwritable speculatively to the OpImage variable due to glslangValidator
// not adding the proper qualifiers.
// If it turns out we need to write to the image after all, remove the qualifier and recompile.
auto *var = maybe_get_backing_variable(ops[0]);
if (var)
{
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
if (has_decoration(var->self, DecorationNonWritable))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
unset_decoration(var->self, DecorationNonWritable);
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
auto &type = expression_type(ops[0]);
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
auto &value_type = expression_type(ops[2]);
auto store_type = value_type;
store_type.vecsize = 4;
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
// imageStore only accepts int coords, not uint.
auto coord_expr = to_expression(ops[1]);
auto target_coord_type = expression_type(ops[1]);
target_coord_type.basetype = SPIRType::Int;
coord_expr = bitcast_expression(target_coord_type, expression_type(ops[1]).basetype, coord_expr);
GLSL: Implement 1D texture emulation for ES. ES does not support 1D images at all. Fake it by promoting 1D images to 2D.
2022-05-27 09:51:34 +00:00
// ES needs to emulate 1D images as 2D.
if (type.image.dim == Dim1D && options.es)
coord_expr = join("ivec2(", coord_expr, ", 0)");
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
if (type.image.ms)
{
uint32_t operands = ops[3];
if (operands != ImageOperandsSampleMask || length != 5)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Multisampled image used in OpImageWrite, but unexpected operand mask was used.");
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
uint32_t samples = ops[4];
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
statement("imageStore(", to_non_uniform_aware_expression(ops[0]), ", ", coord_expr, ", ", to_expression(samples), ", ",
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
remap_swizzle(store_type, value_type.vecsize, to_expression(ops[2])), ");");
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
}
else
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
statement("imageStore(", to_non_uniform_aware_expression(ops[0]), ", ", coord_expr, ", ",
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
remap_swizzle(store_type, value_type.vecsize, to_expression(ops[2])), ");");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (var && variable_storage_is_aliased(*var))
flush_all_aliased_variables();
break;
}
case OpImageQuerySize:
{
auto &type = expression_type(ops[2]);
uint32_t result_type = ops[0];
uint32_t id = ops[1];
if (type.basetype == SPIRType::Image)
{
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
string expr;
if (type.image.sampled == 2)
{
GLSL: Legacy / extension fallbacks for textureSize and texelFetch
2020-11-09 14:26:46 +00:00
if (!options.es && options.version < 430)
require_extension_internal("GL_ARB_shader_image_size");
else if (options.es && options.version < 310)
SPIRV_CROSS_THROW("At least ESSL 3.10 required for imageSize.");
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
// The size of an image is always constant.
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
expr = join("imageSize(", to_non_uniform_aware_expression(ops[2]), ")");
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
}
else
{
// This path is hit for samplerBuffers and multisampled images which do not have LOD.
GLSL: Legacy / extension fallbacks for textureSize and texelFetch
2020-11-09 14:26:46 +00:00
std::string fname = "textureSize";
if (is_legacy())
{
auto &imgtype = get<SPIRType>(type.self);
fname = legacy_tex_op(fname, imgtype, ops[2]);
}
expr = join(fname, "(", convert_separate_image_to_expression(ops[2]), ")");
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
}
auto &restype = get<SPIRType>(ops[0]);
expr = bitcast_expression(restype, SPIRType::Int, expr);
emit_op(result_type, id, expr, true);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Invalid type for OpImageQuerySize.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
Add supprot for the SPV_QCOM_image_processing extension
2023-12-12 22:19:29 +00:00
case OpImageSampleWeightedQCOM:
case OpImageBoxFilterQCOM:
case OpImageBlockMatchSSDQCOM:
case OpImageBlockMatchSADQCOM:
{
require_extension_internal("GL_QCOM_image_processing");
uint32_t result_type_id = ops[0];
uint32_t id = ops[1];
string expr;
switch (opcode)
{
Add supprot for the SPV_QCOM_image_processing extension
2024-01-08 17:58:27 +00:00
case OpImageSampleWeightedQCOM:
expr = "textureWeightedQCOM";
break;
case OpImageBoxFilterQCOM:
expr = "textureBoxFilterQCOM";
break;
case OpImageBlockMatchSSDQCOM:
expr = "textureBlockMatchSSDQCOM";
break;
case OpImageBlockMatchSADQCOM:
expr = "textureBlockMatchSADQCOM";
break;
default:
SPIRV_CROSS_THROW("Invalid opcode for QCOM_image_processing.");
Add supprot for the SPV_QCOM_image_processing extension
2023-12-12 22:19:29 +00:00
}
expr += "(";
bool forward = false;
expr += to_expression(ops[2]);
expr += ", " + to_expression(ops[3]);
switch (opcode)
{
Add supprot for the SPV_QCOM_image_processing extension
2024-01-08 17:58:27 +00:00
case OpImageSampleWeightedQCOM:
expr += ", " + to_non_uniform_aware_expression(ops[4]);
break;
case OpImageBoxFilterQCOM:
expr += ", " + to_expression(ops[4]);
break;
case OpImageBlockMatchSSDQCOM:
case OpImageBlockMatchSADQCOM:
expr += ", " + to_non_uniform_aware_expression(ops[4]);
expr += ", " + to_expression(ops[5]);
expr += ", " + to_expression(ops[6]);
break;
default:
SPIRV_CROSS_THROW("Invalid opcode for QCOM_image_processing.");
Add supprot for the SPV_QCOM_image_processing extension
2023-12-12 22:19:29 +00:00
}
expr += ")";
emit_op(result_type_id, id, expr, forward);
inherit_expression_dependencies(id, ops[3]);
Add supprot for the SPV_QCOM_image_processing extension
2024-01-08 17:58:27 +00:00
if (opcode == OpImageBlockMatchSSDQCOM || opcode == OpImageBlockMatchSADQCOM)
Add supprot for the SPV_QCOM_image_processing extension
2023-12-12 22:19:29 +00:00
inherit_expression_dependencies(id, ops[5]);
break;
}
support for SPV_QCOM_image_processing2 o shaders/asm/frag/locations-components.asm.frag o shaders/vulkan/frag/block-match-gather-sad.frag o shaders/vulkan/frag/block-match-gather-ssd.frag o shaders/vulkan/frag/block-match-window-sad.frag fixed a couple of tests o shaders/asm/frag/locations-components.asm.frag o shaders/vulkan/vert/small-storage.vk.vert
2024-10-08 06:25:04 +00:00
case OpImageBlockMatchWindowSSDQCOM:
case OpImageBlockMatchWindowSADQCOM:
case OpImageBlockMatchGatherSSDQCOM:
case OpImageBlockMatchGatherSADQCOM:
{
require_extension_internal("GL_QCOM_image_processing2");
uint32_t result_type_id = ops[0];
uint32_t id = ops[1];
string expr;
switch (opcode)
{
case OpImageBlockMatchWindowSSDQCOM:
expr = "textureBlockMatchWindowSSDQCOM";
break;
case OpImageBlockMatchWindowSADQCOM:
expr = "textureBlockMatchWindowSADQCOM";
break;
case OpImageBlockMatchGatherSSDQCOM:
expr = "textureBlockMatchGatherSSDQCOM";
break;
case OpImageBlockMatchGatherSADQCOM:
expr = "textureBlockMatchGatherSADQCOM";
break;
default:
SPIRV_CROSS_THROW("Invalid opcode for QCOM_image_processing2.");
}
expr += "(";
bool forward = false;
expr += to_expression(ops[2]);
expr += ", " + to_expression(ops[3]);
expr += ", " + to_non_uniform_aware_expression(ops[4]);
expr += ", " + to_expression(ops[5]);
expr += ", " + to_expression(ops[6]);
expr += ")";
emit_op(result_type_id, id, expr, forward);
inherit_expression_dependencies(id, ops[3]);
inherit_expression_dependencies(id, ops[5]);
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Compute
case OpControlBarrier:
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
case OpMemoryBarrier:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
uint32_t execution_scope = 0;
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
uint32_t memory;
uint32_t semantics;
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
if (opcode == OpMemoryBarrier)
{
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
memory = evaluate_constant_u32(ops[0]);
semantics = evaluate_constant_u32(ops[1]);
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
}
else
{
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
execution_scope = evaluate_constant_u32(ops[0]);
memory = evaluate_constant_u32(ops[1]);
semantics = evaluate_constant_u32(ops[2]);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
if (execution_scope == ScopeSubgroup || memory == ScopeSubgroup)
{
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
// OpControlBarrier with ScopeSubgroup is subgroupBarrier()
if (opcode != OpControlBarrier)
{
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupMemBarrier);
}
else
{
request_subgroup_feature(ShaderSubgroupSupportHelper::SubgroupBarrier);
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
}
if (execution_scope != ScopeSubgroup && get_entry_point().model == ExecutionModelTessellationControl)
{
// Control shaders only have barriers, and it implies memory barriers.
if (opcode == OpControlBarrier)
statement("barrier();");
break;
}
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
// We only care about these flags, acquire/release and friends are not relevant to GLSL.
semantics = mask_relevant_memory_semantics(semantics);
if (opcode == OpMemoryBarrier)
{
// If we are a memory barrier, and the next instruction is a control barrier, check if that memory barrier
// does what we need, so we avoid redundant barriers.
const Instruction *next = get_next_instruction_in_block(instruction);
if (next && next->op == OpControlBarrier)
{
auto *next_ops = stream(*next);
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
uint32_t next_memory = evaluate_constant_u32(next_ops[1]);
uint32_t next_semantics = evaluate_constant_u32(next_ops[2]);
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
next_semantics = mask_relevant_memory_semantics(next_semantics);
Optimize away redundant barriers.
2018-01-09 11:17:38 +00:00
bool memory_scope_covered = false;
if (next_memory == memory)
memory_scope_covered = true;
else if (next_semantics == MemorySemanticsWorkgroupMemoryMask)
{
// If we only care about workgroup memory, either Device or Workgroup scope is fine,
// scope does not have to match.
if ((next_memory == ScopeDevice || next_memory == ScopeWorkgroup) &&
(memory == ScopeDevice || memory == ScopeWorkgroup))
{
memory_scope_covered = true;
}
}
else if (memory == ScopeWorkgroup && next_memory == ScopeDevice)
{
// The control barrier has device scope, but the memory barrier just has workgroup scope.
memory_scope_covered = true;
}
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
// If we have the same memory scope, and all memory types are covered, we're good.
Optimize away redundant barriers.
2018-01-09 11:17:38 +00:00
if (memory_scope_covered && (semantics & next_semantics) == semantics)
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
break;
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
// We are synchronizing some memory or syncing execution,
// so we cannot forward any loads beyond the memory barrier.
if (semantics || opcode == OpControlBarrier)
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
{
assert(current_emitting_block);
flush_control_dependent_expressions(current_emitting_block->self);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
flush_all_active_variables();
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
if (memory == ScopeWorkgroup) // Only need to consider memory within a group
{
if (semantics == MemorySemanticsWorkgroupMemoryMask)
Don't emit memoryBarrierShared() in workgroup control barriers. This is implied in both GL and GLES. Emitting memoryBarrierShared() was based on earlier confusion in the spec which has since been fixed and clarified.
2019-12-04 14:06:19 +00:00
{
// OpControlBarrier implies a memory barrier for shared memory as well.
bool implies_shared_barrier = opcode == OpControlBarrier && execution_scope == ScopeWorkgroup;
if (!implies_shared_barrier)
statement("memoryBarrierShared();");
}
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
else if (semantics != 0)
statement("groupMemoryBarrier();");
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
else if (memory == ScopeSubgroup)
{
Run format_all.sh.
2018-04-17 13:01:31 +00:00
const uint32_t all_barriers =
MemorySemanticsWorkgroupMemoryMask | MemorySemanticsUniformMemoryMask | MemorySemanticsImageMemoryMask;
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
if (semantics & (MemorySemanticsCrossWorkgroupMemoryMask | MemorySemanticsSubgroupMemoryMask))
{
// These are not relevant for GLSL, but assume it means memoryBarrier().
// memoryBarrier() does everything, so no need to test anything else.
statement("subgroupMemoryBarrier();");
}
else if ((semantics & all_barriers) == all_barriers)
{
// Short-hand instead of emitting 3 barriers.
statement("subgroupMemoryBarrier();");
}
else
{
// Pick out individual barriers.
if (semantics & MemorySemanticsWorkgroupMemoryMask)
statement("subgroupMemoryBarrierShared();");
if (semantics & MemorySemanticsUniformMemoryMask)
statement("subgroupMemoryBarrierBuffer();");
if (semantics & MemorySemanticsImageMemoryMask)
statement("subgroupMemoryBarrierImage();");
}
}
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
else
{
Run format_all.sh.
2020-01-08 09:48:30 +00:00
const uint32_t all_barriers =
MemorySemanticsWorkgroupMemoryMask | MemorySemanticsUniformMemoryMask | MemorySemanticsImageMemoryMask;
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
if (semantics & (MemorySemanticsCrossWorkgroupMemoryMask | MemorySemanticsSubgroupMemoryMask))
{
// These are not relevant for GLSL, but assume it means memoryBarrier().
// memoryBarrier() does everything, so no need to test anything else.
statement("memoryBarrier();");
}
else if ((semantics & all_barriers) == all_barriers)
{
// Short-hand instead of emitting 4 barriers.
statement("memoryBarrier();");
}
else
{
// Pick out individual barriers.
if (semantics & MemorySemanticsWorkgroupMemoryMask)
statement("memoryBarrierShared();");
if (semantics & MemorySemanticsUniformMemoryMask)
statement("memoryBarrierBuffer();");
if (semantics & MemorySemanticsImageMemoryMask)
statement("memoryBarrierImage();");
}
}
if (opcode == OpControlBarrier)
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
{
if (execution_scope == ScopeSubgroup)
statement("subgroupBarrier();");
else
statement("barrier();");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case OpExtInst:
{
uint32_t extension_set = ops[2];
GLSL: Support GL_EXT_debug_printf.
2022-04-19 10:07:54 +00:00
auto ext = get<SPIRExtension>(extension_set).ext;
Add support for new extensions.
2017-11-21 13:04:57 +00:00
GLSL: Support GL_EXT_debug_printf.
2022-04-19 10:07:54 +00:00
if (ext == SPIRExtension::GLSL)
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
emit_glsl_op(ops[0], ops[1], ops[3], &ops[4], length - 4);
}
GLSL: Support GL_EXT_debug_printf.
2022-04-19 10:07:54 +00:00
else if (ext == SPIRExtension::SPV_AMD_shader_ballot)
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
emit_spv_amd_shader_ballot_op(ops[0], ops[1], ops[3], &ops[4], length - 4);
}
GLSL: Support GL_EXT_debug_printf.
2022-04-19 10:07:54 +00:00
else if (ext == SPIRExtension::SPV_AMD_shader_explicit_vertex_parameter)
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
emit_spv_amd_shader_explicit_vertex_parameter_op(ops[0], ops[1], ops[3], &ops[4], length - 4);
}
GLSL: Support GL_EXT_debug_printf.
2022-04-19 10:07:54 +00:00
else if (ext == SPIRExtension::SPV_AMD_shader_trinary_minmax)
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
emit_spv_amd_shader_trinary_minmax_op(ops[0], ops[1], ops[3], &ops[4], length - 4);
}
GLSL: Support GL_EXT_debug_printf.
2022-04-19 10:07:54 +00:00
else if (ext == SPIRExtension::SPV_AMD_gcn_shader)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Add support for new extensions.
2017-11-21 13:04:57 +00:00
emit_spv_amd_gcn_shader_op(ops[0], ops[1], ops[3], &ops[4], length - 4);
}
Handle ShaderDebugInfo non-semantic extension.
2022-11-08 11:14:51 +00:00
else if (ext == SPIRExtension::SPV_debug_info ||
Also consider NonSemantic ExtInst in block_is_noop.
2023-01-12 11:41:19 +00:00
ext == SPIRExtension::NonSemanticShaderDebugInfo ||
ext == SPIRExtension::NonSemanticGeneric)
Parse SPIR-V debug information extended instructions, as well as OpNoLine. No impact on result shader string.
2019-07-04 08:03:06 +00:00
{
break; // Ignore SPIR-V debug information extended instructions.
}
GLSL: Support GL_EXT_debug_printf.
2022-04-19 10:07:54 +00:00
else if (ext == SPIRExtension::NonSemanticDebugPrintf)
{
// Operation 1 is printf.
if (ops[3] == 1)
{
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Debug printf is only supported in Vulkan GLSL.\n");
require_extension_internal("GL_EXT_debug_printf");
auto &format_string = get<SPIRString>(ops[4]).str;
string expr = join("debugPrintfEXT(\"", format_string, "\"");
for (uint32_t i = 5; i < length; i++)
{
expr += ", ";
expr += to_expression(ops[i]);
}
statement(expr, ");");
}
}
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
else
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("// unimplemented ext op ", instruction.op);
break;
}
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
// Legacy sub-group stuff ...
Add support for new extensions.
2017-11-21 13:04:57 +00:00
case OpSubgroupBallotKHR:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
string expr;
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
expr = join("uvec4(unpackUint2x32(ballotARB(" + to_expression(ops[2]) + ")), 0u, 0u)");
Implement packHalf2x16/unpackHalf2x16 on MSL.
2018-03-12 16:51:14 +00:00
emit_op(result_type, id, expr, should_forward(ops[2]));
Add support for new extensions.
2017-11-21 13:04:57 +00:00
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_shader_ballot");
Make sure ballotARB inherits expression dependencies.
2018-03-12 16:42:48 +00:00
inherit_expression_dependencies(id, ops[2]);
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpSubgroupFirstInvocationKHR:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
emit_unary_func_op(result_type, id, ops[2], "readFirstInvocationARB");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_shader_ballot");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpSubgroupReadInvocationKHR:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
emit_binary_func_op(result_type, id, ops[2], ops[3], "readInvocationARB");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_shader_ballot");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpSubgroupAllKHR:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
emit_unary_func_op(result_type, id, ops[2], "allInvocationsARB");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_shader_group_vote");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpSubgroupAnyKHR:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
emit_unary_func_op(result_type, id, ops[2], "anyInvocationARB");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_shader_group_vote");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpSubgroupAllEqualKHR:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
emit_unary_func_op(result_type, id, ops[2], "allInvocationsEqualARB");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_shader_group_vote");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpGroupIAddNonUniformAMD:
case OpGroupFAddNonUniformAMD:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
emit_unary_func_op(result_type, id, ops[4], "addInvocationsNonUniformAMD");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_AMD_shader_ballot");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpGroupFMinNonUniformAMD:
case OpGroupUMinNonUniformAMD:
case OpGroupSMinNonUniformAMD:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
emit_unary_func_op(result_type, id, ops[4], "minInvocationsNonUniformAMD");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_AMD_shader_ballot");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpGroupFMaxNonUniformAMD:
case OpGroupUMaxNonUniformAMD:
case OpGroupSMaxNonUniformAMD:
{
uint32_t result_type = ops[0];
uint32_t id = ops[1];
emit_unary_func_op(result_type, id, ops[4], "maxInvocationsNonUniformAMD");
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_AMD_shader_ballot");
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
register_control_dependent_expression(ops[1]);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpFragmentMaskFetchAMD:
{
auto &type = expression_type(ops[2]);
uint32_t result_type = ops[0];
uint32_t id = ops[1];
if (type.image.dim == spv::DimSubpassData)
{
emit_unary_func_op(result_type, id, ops[2], "fragmentMaskFetchAMD");
}
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
else
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
emit_binary_func_op(result_type, id, ops[2], ops[3], "fragmentMaskFetchAMD");
}
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_AMD_shader_fragment_mask");
Add support for new extensions.
2017-11-21 13:04:57 +00:00
break;
}
case OpFragmentFetchAMD:
{
auto &type = expression_type(ops[2]);
uint32_t result_type = ops[0];
uint32_t id = ops[1];
if (type.image.dim == spv::DimSubpassData)
{
emit_binary_func_op(result_type, id, ops[2], ops[4], "fragmentFetchAMD");
}
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
else
Add support for new extensions.
2017-11-21 13:04:57 +00:00
{
emit_trinary_func_op(result_type, id, ops[2], ops[3], ops[4], "fragmentFetchAMD");
}
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_AMD_shader_fragment_mask");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
// Vulkan 1.1 sub-group stuff ...
case OpGroupNonUniformElect:
case OpGroupNonUniformBroadcast:
case OpGroupNonUniformBroadcastFirst:
case OpGroupNonUniformBallot:
case OpGroupNonUniformInverseBallot:
case OpGroupNonUniformBallotBitExtract:
case OpGroupNonUniformBallotBitCount:
case OpGroupNonUniformBallotFindLSB:
case OpGroupNonUniformBallotFindMSB:
case OpGroupNonUniformShuffle:
case OpGroupNonUniformShuffleXor:
case OpGroupNonUniformShuffleUp:
case OpGroupNonUniformShuffleDown:
case OpGroupNonUniformAll:
case OpGroupNonUniformAny:
case OpGroupNonUniformAllEqual:
case OpGroupNonUniformFAdd:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
case OpGroupNonUniformIAdd:
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformFMul:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
case OpGroupNonUniformIMul:
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformFMin:
case OpGroupNonUniformFMax:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
case OpGroupNonUniformSMin:
case OpGroupNonUniformSMax:
case OpGroupNonUniformUMin:
case OpGroupNonUniformUMax:
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformBitwiseAnd:
case OpGroupNonUniformBitwiseOr:
case OpGroupNonUniformBitwiseXor:
GLSL: Add support for Logical subgroup ops. Completely missed these ...
2021-03-08 11:06:46 +00:00
case OpGroupNonUniformLogicalAnd:
case OpGroupNonUniformLogicalOr:
case OpGroupNonUniformLogicalXor:
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case OpGroupNonUniformQuadSwap:
case OpGroupNonUniformQuadBroadcast:
emit_subgroup_op(instruction);
break;
Fail more gracefully with some unsupported opcodes.
2018-07-02 11:22:21 +00:00
case OpFUnordEqual:
case OpFUnordLessThan:
case OpFUnordGreaterThan:
case OpFUnordLessThanEqual:
case OpFUnordGreaterThanEqual:
GLSL: Support unordered floating point compare. There is no direct way to express this, so invert boolean results to force any NaN -> true. glslang emits Ordered compare instructions everywhere, and the GLSL spec is not clear on this, so assume this is fine.
2019-10-14 11:48:22 +00:00
{
// GLSL doesn't specify if floating point comparisons are ordered or unordered,
// but glslang always emits ordered floating point compares for GLSL.
// To get unordered compares, we can test the opposite thing and invert the result.
// This way, we force true when there is any NaN present.
uint32_t op0 = ops[2];
uint32_t op1 = ops[3];
string expr;
if (expression_type(op0).vecsize > 1)
{
const char *comp_op = nullptr;
switch (opcode)
{
case OpFUnordEqual:
comp_op = "notEqual";
break;
case OpFUnordLessThan:
comp_op = "greaterThanEqual";
break;
case OpFUnordLessThanEqual:
comp_op = "greaterThan";
break;
case OpFUnordGreaterThan:
comp_op = "lessThanEqual";
break;
case OpFUnordGreaterThanEqual:
comp_op = "lessThan";
break;
default:
assert(0);
break;
}
expr = join("not(", comp_op, "(", to_unpacked_expression(op0), ", ", to_unpacked_expression(op1), "))");
}
else
{
const char *comp_op = nullptr;
switch (opcode)
{
case OpFUnordEqual:
comp_op = " != ";
break;
case OpFUnordLessThan:
comp_op = " >= ";
break;
case OpFUnordLessThanEqual:
comp_op = " > ";
break;
case OpFUnordGreaterThan:
comp_op = " <= ";
break;
case OpFUnordGreaterThanEqual:
comp_op = " < ";
break;
default:
assert(0);
break;
}
expr = join("!(", to_enclosed_unpacked_expression(op0), comp_op, to_enclosed_unpacked_expression(op1), ")");
}
emit_op(ops[0], ops[1], expr, should_forward(op0) && should_forward(op1));
inherit_expression_dependencies(ops[1], op0);
inherit_expression_dependencies(ops[1], op1);
Fail more gracefully with some unsupported opcodes.
2018-07-02 11:22:21 +00:00
break;
GLSL: Support unordered floating point compare. There is no direct way to express this, so invert boolean results to force any NaN -> true. glslang emits Ordered compare instructions everywhere, and the GLSL spec is not clear on this, so assume this is fine.
2019-10-14 11:48:22 +00:00
}
Fail more gracefully with some unsupported opcodes.
2018-07-02 11:22:21 +00:00
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
case OpReportIntersectionKHR:
// NV is same opcode.
forced_temporaries.insert(ops[1]);
if (ray_tracing_is_khr)
GLSL_BFOP(reportIntersectionEXT);
else
GLSL_BFOP(reportIntersectionNV);
GLSL: Add some more focused RT test shaders.
2020-05-20 11:14:23 +00:00
flush_control_dependent_expressions(current_emitting_block->self);
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
break;
case OpIgnoreIntersectionNV:
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
// KHR variant is a terminator.
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
statement("ignoreIntersectionNV();");
GLSL: Add some more focused RT test shaders.
2020-05-20 11:14:23 +00:00
flush_control_dependent_expressions(current_emitting_block->self);
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
break;
case OpTerminateRayNV:
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
// KHR variant is a terminator.
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
statement("terminateRayNV();");
GLSL: Add some more focused RT test shaders.
2020-05-20 11:14:23 +00:00
flush_control_dependent_expressions(current_emitting_block->self);
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
break;
case OpTraceNV:
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
statement("traceNV(", to_non_uniform_aware_expression(ops[0]), ", ", to_expression(ops[1]), ", ", to_expression(ops[2]), ", ",
Replace usage of "require_extension" with "require_extension_internal" and "to_func_call_arg" with "to_expression"
2019-03-26 13:04:39 +00:00
to_expression(ops[3]), ", ", to_expression(ops[4]), ", ", to_expression(ops[5]), ", ",
to_expression(ops[6]), ", ", to_expression(ops[7]), ", ", to_expression(ops[8]), ", ",
to_expression(ops[9]), ", ", to_expression(ops[10]), ");");
GLSL: Add some more focused RT test shaders.
2020-05-20 11:14:23 +00:00
flush_control_dependent_expressions(current_emitting_block->self);
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
break;
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
case OpTraceRayKHR:
if (!has_decoration(ops[10], DecorationLocation))
SPIRV_CROSS_THROW("A memory declaration object must be used in TraceRayKHR.");
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
statement("traceRayEXT(", to_non_uniform_aware_expression(ops[0]), ", ", to_expression(ops[1]), ", ", to_expression(ops[2]), ", ",
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
to_expression(ops[3]), ", ", to_expression(ops[4]), ", ", to_expression(ops[5]), ", ",
to_expression(ops[6]), ", ", to_expression(ops[7]), ", ", to_expression(ops[8]), ", ",
to_expression(ops[9]), ", ", get_decoration(ops[10], DecorationLocation), ");");
flush_control_dependent_expressions(current_emitting_block->self);
break;
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
case OpExecuteCallableNV:
Replace usage of "require_extension" with "require_extension_internal" and "to_func_call_arg" with "to_expression"
2019-03-26 13:04:39 +00:00
statement("executeCallableNV(", to_expression(ops[0]), ", ", to_expression(ops[1]), ");");
GLSL: Add some more focused RT test shaders.
2020-05-20 11:14:23 +00:00
flush_control_dependent_expressions(current_emitting_block->self);
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
break;
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
case OpExecuteCallableKHR:
if (!has_decoration(ops[1], DecorationLocation))
SPIRV_CROSS_THROW("A memory declaration object must be used in ExecuteCallableKHR.");
statement("executeCallableEXT(", to_expression(ops[0]), ", ", get_decoration(ops[1], DecorationLocation), ");");
flush_control_dependent_expressions(current_emitting_block->self);
break;
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
// Don't bother forwarding temporaries. Avoids having to test expression invalidation with ray query objects.
case OpRayQueryInitializeKHR:
GLSL: Ensure ray query object decls are flushed if allocated in Function. glslang always emits Private variables, but DXC not so much.
2021-07-20 10:03:07 +00:00
flush_variable_declaration(ops[0]);
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
statement("rayQueryInitializeEXT(",
to_expression(ops[0]), ", ", to_expression(ops[1]), ", ",
to_expression(ops[2]), ", ", to_expression(ops[3]), ", ",
to_expression(ops[4]), ", ", to_expression(ops[5]), ", ",
to_expression(ops[6]), ", ", to_expression(ops[7]), ");");
break;
case OpRayQueryProceedKHR:
GLSL: Ensure ray query object decls are flushed if allocated in Function. glslang always emits Private variables, but DXC not so much.
2021-07-20 10:03:07 +00:00
flush_variable_declaration(ops[0]);
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
emit_op(ops[0], ops[1], join("rayQueryProceedEXT(", to_expression(ops[2]), ")"), false);
break;
case OpRayQueryTerminateKHR:
GLSL: Ensure ray query object decls are flushed if allocated in Function. glslang always emits Private variables, but DXC not so much.
2021-07-20 10:03:07 +00:00
flush_variable_declaration(ops[0]);
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
statement("rayQueryTerminateEXT(", to_expression(ops[0]), ");");
break;
case OpRayQueryGenerateIntersectionKHR:
GLSL: Ensure ray query object decls are flushed if allocated in Function. glslang always emits Private variables, but DXC not so much.
2021-07-20 10:03:07 +00:00
flush_variable_declaration(ops[0]);
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
statement("rayQueryGenerateIntersectionEXT(", to_expression(ops[0]), ", ", to_expression(ops[1]), ");");
break;
case OpRayQueryConfirmIntersectionKHR:
GLSL: Ensure ray query object decls are flushed if allocated in Function. glslang always emits Private variables, but DXC not so much.
2021-07-20 10:03:07 +00:00
flush_variable_declaration(ops[0]);
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
statement("rayQueryConfirmIntersectionEXT(", to_expression(ops[0]), ");");
break;
#define GLSL_RAY_QUERY_GET_OP(op) \
case OpRayQueryGet##op##KHR: \
GLSL: Ensure ray query object decls are flushed if allocated in Function. glslang always emits Private variables, but DXC not so much.
2021-07-20 10:03:07 +00:00
flush_variable_declaration(ops[2]); \
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
emit_op(ops[0], ops[1], join("rayQueryGet" #op "EXT(", to_expression(ops[2]), ")"), false); \
break
#define GLSL_RAY_QUERY_GET_OP2(op) \
case OpRayQueryGet##op##KHR: \
GLSL: Ensure ray query object decls are flushed if allocated in Function. glslang always emits Private variables, but DXC not so much.
2021-07-20 10:03:07 +00:00
flush_variable_declaration(ops[2]); \
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
emit_op(ops[0], ops[1], join("rayQueryGet" #op "EXT(", to_expression(ops[2]), ", ", "bool(", to_expression(ops[3]), "))"), false); \
break
GLSL_RAY_QUERY_GET_OP(RayTMin);
GLSL_RAY_QUERY_GET_OP(RayFlags);
GLSL_RAY_QUERY_GET_OP(WorldRayOrigin);
GLSL_RAY_QUERY_GET_OP(WorldRayDirection);
GLSL_RAY_QUERY_GET_OP(IntersectionCandidateAABBOpaque);
GLSL_RAY_QUERY_GET_OP2(IntersectionType);
GLSL_RAY_QUERY_GET_OP2(IntersectionT);
GLSL_RAY_QUERY_GET_OP2(IntersectionInstanceCustomIndex);
GLSL_RAY_QUERY_GET_OP2(IntersectionInstanceId);
GLSL_RAY_QUERY_GET_OP2(IntersectionInstanceShaderBindingTableRecordOffset);
GLSL_RAY_QUERY_GET_OP2(IntersectionGeometryIndex);
GLSL_RAY_QUERY_GET_OP2(IntersectionPrimitiveIndex);
GLSL_RAY_QUERY_GET_OP2(IntersectionBarycentrics);
GLSL_RAY_QUERY_GET_OP2(IntersectionFrontFace);
GLSL_RAY_QUERY_GET_OP2(IntersectionObjectRayDirection);
GLSL_RAY_QUERY_GET_OP2(IntersectionObjectRayOrigin);
GLSL_RAY_QUERY_GET_OP2(IntersectionObjectToWorld);
GLSL_RAY_QUERY_GET_OP2(IntersectionWorldToObject);
#undef GLSL_RAY_QUERY_GET_OP
#undef GLSL_RAY_QUERY_GET_OP2
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
case OpConvertUToAccelerationStructureKHR:
GLSL: Handle forced temporary OpConvertUToAccelerationStructureKHR. Need to lower to temporary before casting to RTAS.
2022-06-17 11:05:08 +00:00
{
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
require_extension_internal("GL_EXT_ray_tracing");
GLSL: Handle forced temporary OpConvertUToAccelerationStructureKHR. Need to lower to temporary before casting to RTAS.
2022-06-17 11:05:08 +00:00
bool elide_temporary = should_forward(ops[2]) && forced_temporaries.count(ops[1]) == 0 &&
!hoisted_temporaries.count(ops[1]);
if (elide_temporary)
{
GLSL_UFOP(accelerationStructureEXT);
}
else
{
// Force this path in subsequent iterations.
forced_temporaries.insert(ops[1]);
// We cannot declare a temporary acceleration structure in GLSL.
// If we get to this point, we'll have to emit a temporary uvec2,
// and cast to RTAS on demand.
statement(declare_temporary(expression_type_id(ops[2]), ops[1]), to_unpacked_expression(ops[2]), ";");
// Use raw SPIRExpression interface to block all usage tracking.
set<SPIRExpression>(ops[1], join("accelerationStructureEXT(", to_name(ops[1]), ")"), ops[0], true);
}
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
break;
GLSL: Handle forced temporary OpConvertUToAccelerationStructureKHR. Need to lower to temporary before casting to RTAS.
2022-06-17 11:05:08 +00:00
}
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
case OpConvertUToPtr:
{
auto &type = get<SPIRType>(ops[0]);
if (type.storage != StorageClassPhysicalStorageBufferEXT)
SPIRV_CROSS_THROW("Only StorageClassPhysicalStorageBufferEXT is supported by OpConvertUToPtr.");
GLSL: Emit GL_EXT_buffer_reference_uvec2 as required.
2021-09-02 11:11:36 +00:00
auto &in_type = expression_type(ops[2]);
if (in_type.vecsize == 2)
require_extension_internal("GL_EXT_buffer_reference_uvec2");
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
auto op = type_to_glsl(type);
emit_unary_func_op(ops[0], ops[1], ops[2], op.c_str());
break;
}
case OpConvertPtrToU:
{
auto &type = get<SPIRType>(ops[0]);
auto &ptr_type = expression_type(ops[2]);
if (ptr_type.storage != StorageClassPhysicalStorageBufferEXT)
SPIRV_CROSS_THROW("Only StorageClassPhysicalStorageBufferEXT is supported by OpConvertPtrToU.");
GLSL: Emit GL_EXT_buffer_reference_uvec2 as required.
2021-09-02 11:11:36 +00:00
if (type.vecsize == 2)
require_extension_internal("GL_EXT_buffer_reference_uvec2");
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
auto op = type_to_glsl(type);
emit_unary_func_op(ops[0], ops[1], ops[2], op.c_str());
break;
}
Add OpUndef instruction to block's instruction list for completeness.
2019-04-08 11:45:31 +00:00
case OpUndef:
// Undefined value has been declared.
break;
Support emitting OpLine directive. Facilitates easier mapping from source language to cross-compiled output in tooling.
2019-05-28 11:41:46 +00:00
case OpLine:
{
emit_line_directive(ops[0], ops[1]);
break;
}
Parse SPIR-V debug information extended instructions, as well as OpNoLine. No impact on result shader string.
2019-07-04 08:03:06 +00:00
case OpNoLine:
break;
Support the SPV_EXT_demote_to_helper_invocation extension. This extension provides a new operation which causes a fragment to be discarded without terminating the fragment shader invocation. The invocation for the discarded fragment becomes a helper invocation, so that derivatives will remain defined. The old `HelperInvocation` builtin becomes undefined when this occurs, so a second new instruction queries the current helper invocation status. This is only fully supported for GLSL. HLSL doesn't support the `IsHelperInvocation` operation and MSL doesn't support the `DemoteToHelperInvocation` op. Fixes #1052.
2019-07-13 20:57:33 +00:00
case OpDemoteToHelperInvocationEXT:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("GL_EXT_demote_to_helper_invocation is only supported in Vulkan GLSL.");
require_extension_internal("GL_EXT_demote_to_helper_invocation");
statement(backend.demote_literal, ";");
break;
case OpIsHelperInvocationEXT:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("GL_EXT_demote_to_helper_invocation is only supported in Vulkan GLSL.");
require_extension_internal("GL_EXT_demote_to_helper_invocation");
HLSL: Implement HelperInvocationEXT. It is volatile by nature and must not be forwarded.
2022-03-04 09:54:31 +00:00
// Helper lane state with demote is volatile by nature.
// Do not forward this.
Don't forward uses of an OpIsHelperInvocationEXT op. If this is computed *before* a `demote`, but used *after*, forwarding it will produce the wrong value. This does make for uglier shaders, but it's necessary right now to ensure correctness. I needed to use an assembly shader to produce the test for this. `spirv-opt` is not smart enough (or too smart?) to eliminate the variable that would be used in GLSL to express this.
2019-07-18 22:32:35 +00:00
emit_op(ops[0], ops[1], "helperInvocationEXT()", false);
Support the SPV_EXT_demote_to_helper_invocation extension. This extension provides a new operation which causes a fragment to be discarded without terminating the fragment shader invocation. The invocation for the discarded fragment becomes a helper invocation, so that derivatives will remain defined. The old `HelperInvocation` builtin becomes undefined when this occurs, so a second new instruction queries the current helper invocation status. This is only fully supported for GLSL. HLSL doesn't support the `IsHelperInvocation` operation and MSL doesn't support the `DemoteToHelperInvocation` op. Fixes #1052.
2019-07-13 20:57:33 +00:00
break;
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
case OpBeginInvocationInterlockEXT:
Deal with complex interlock cases in GLSL.
2019-09-04 10:18:04 +00:00
// If the interlock is complex, we emit this elsewhere.
if (!interlocked_is_complex)
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
{
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
statement("SPIRV_Cross_beginInvocationInterlock();");
Make sure not to propagate loads outside interlock region.
2019-09-04 10:33:20 +00:00
flush_all_active_variables();
// Make sure forwarding doesn't propagate outside interlock region.
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
}
break;
case OpEndInvocationInterlockEXT:
Deal with complex interlock cases in GLSL.
2019-09-04 10:18:04 +00:00
// If the interlock is complex, we emit this elsewhere.
if (!interlocked_is_complex)
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
{
SPIRV-Cross contribution needed for `INTEL_fragment_shader_ordering`
2021-10-19 06:09:55 +00:00
statement("SPIRV_Cross_endInvocationInterlock();");
Make sure not to propagate loads outside interlock region.
2019-09-04 10:33:20 +00:00
flush_all_active_variables();
// Make sure forwarding doesn't propagate outside interlock region.
Support the SPV_EXT_fragment_shader_interlock extension. This was straightforward to implement in GLSL. The `ShadingRateInterlockOrderedEXT` and `ShadingRateInterlockUnorderedEXT` modes aren't implemented yet, because we don't support `SPV_NV_shading_rate` or `SPV_EXT_fragment_invocation_density` yet. HLSL and MSL were more interesting. They don't support this directly, but they do support marking resources as "rasterizer ordered," which does roughly the same thing. So this implementation scans all accesses inside the critical section and marks all storage resources found therein as rasterizer ordered. They also don't support the fine-grained controls on pixel- vs. sample-level interlock and disabling ordering guarantees that GLSL and SPIR-V do, but that's OK. "Unordered" here merely means the order is undefined; that it just so happens to be the same as rasterizer order is immaterial. As for pixel- vs. sample-level interlock, Vulkan explicitly states: > With sample shading enabled, [the `PixelInterlockOrderedEXT` and > `PixelInterlockUnorderedEXT`] execution modes are treated like > `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT` > respectively. and: > If [the `SampleInterlockOrderedEXT` or `SampleInterlockUnorderedEXT`] > execution modes are used in single-sample mode they are treated like > `PixelInterlockOrderedEXT` or `PixelInterlockUnorderedEXT` > respectively. So this will DTRT for MoltenVK and gfx-rs, at least. MSL additionally supports multiple raster order groups; resources that are not accessed together can be placed in different ROGs to allow them to be synchronized separately. A more sophisticated analysis might be able to place resources optimally, but that's outside the scope of this change. For now, we assign all resources to group 0, which should do for our purposes. `glslang` doesn't support the `RasterizerOrdered` UAVs this implementation produces for HLSL, so the test case needs `fxc.exe`. It also insists on GLSL 4.50 for `GL_ARB_fragment_shader_interlock`, even though the spec says it needs either 4.20 or `GL_ARB_shader_image_load_store`; and it doesn't support the `GL_NV_fragment_shader_interlock` extension at all. So I haven't been able to test those code paths. Fixes #1002.
2019-08-04 05:07:20 +00:00
}
break;
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
case OpSetMeshOutputsEXT:
statement("SetMeshOutputsEXT(", to_unpacked_expression(ops[0]), ", ", to_unpacked_expression(ops[1]), ");");
break;
GLSL: Support OpReadClockKHR
2023-01-19 11:15:57 +00:00
case OpReadClockKHR:
{
auto &type = get<SPIRType>(ops[0]);
GLSL: Minor fixes for shader clock implementation.
2023-01-26 13:51:07 +00:00
auto scope = static_cast<Scope>(evaluate_constant_u32(ops[2]));
const char *op = nullptr;
// Forwarding clock statements leads to a scenario where an SSA value can take on different
// values every time it's evaluated. Block any forwarding attempt.
// We also might want to invalidate all expressions to function as a sort of optimization
// barrier, but might be overkill for now.
GLSL: Support OpReadClockKHR
2023-01-19 11:15:57 +00:00
if (scope == ScopeDevice)
{
require_extension_internal("GL_EXT_shader_realtime_clock");
if (type.basetype == SPIRType::BaseType::UInt64)
GLSL: Minor fixes for shader clock implementation.
2023-01-26 13:51:07 +00:00
op = "clockRealtimeEXT()";
GLSL: Support OpReadClockKHR
2023-01-19 11:15:57 +00:00
else if (type.basetype == SPIRType::BaseType::UInt && type.vecsize == 2)
GLSL: Minor fixes for shader clock implementation.
2023-01-26 13:51:07 +00:00
op = "clockRealtime2x32EXT()";
GLSL: Support OpReadClockKHR
2023-01-19 11:15:57 +00:00
else
SPIRV_CROSS_THROW("Unsupported result type for OpReadClockKHR opcode.");
}
else if (scope == ScopeSubgroup)
{
require_extension_internal("GL_ARB_shader_clock");
if (type.basetype == SPIRType::BaseType::UInt64)
GLSL: Minor fixes for shader clock implementation.
2023-01-26 13:51:07 +00:00
op = "clockARB()";
GLSL: Support OpReadClockKHR
2023-01-19 11:15:57 +00:00
else if (type.basetype == SPIRType::BaseType::UInt && type.vecsize == 2)
GLSL: Minor fixes for shader clock implementation.
2023-01-26 13:51:07 +00:00
op = "clock2x32ARB()";
GLSL: Support OpReadClockKHR
2023-01-19 11:15:57 +00:00
else
SPIRV_CROSS_THROW("Unsupported result type for OpReadClockKHR opcode.");
}
else
SPIRV_CROSS_THROW("Unsupported scope for OpReadClockKHR opcode.");
GLSL: Minor fixes for shader clock implementation.
2023-01-26 13:51:07 +00:00
emit_op(ops[0], ops[1], op, false);
GLSL: Support OpReadClockKHR
2023-01-19 11:15:57 +00:00
break;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
statement("// unimplemented op ", instruction.op);
break;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Merge Brenwill fork with upstream.
2016-10-19 21:09:51 +00:00
// Appends function arguments, mapped from global variables, beyond the specified arg index.
For MSL, extract global var refs from within functions and convert them to function args.
2016-07-06 20:55:45 +00:00
// This is used when a function call uses fewer arguments than the function defines.
Merge Brenwill fork with upstream.
2016-10-19 21:09:51 +00:00
// This situation may occur if the function signature has been dynamically modified to
// extract global variables referenced from within the function, and convert them to
// function arguments. This is necessary for shader languages that do not support global
// access to shader input content from within a function (eg. Metal). Each additional
// function args uses the name of the global variable. Function nesting will modify the
CompilerMSL declare threadgroup variables accessed in called functions.
2018-01-24 20:38:17 +00:00
// functions and function calls all the way up the nesting chain.
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
void CompilerGLSL::append_global_func_args(const SPIRFunction &func, uint32_t index, SmallVector<string> &arglist)
For MSL, extract global var refs from within functions and convert them to function args.
2016-07-06 20:55:45 +00:00
{
Run clang-format.
2016-10-24 13:24:24 +00:00
auto &args = func.arguments;
Compliance fixes for pull request. Use C++ style primitive casts. Add BackendVariations.discard_literal to support language variation for discard syntax. Tweaks to custom MSL defines.
2016-10-27 14:20:01 +00:00
uint32_t arg_cnt = uint32_t(args.size());
Run clang-format.
2016-10-24 13:24:24 +00:00
for (uint32_t arg_idx = index; arg_idx < arg_cnt; arg_idx++)
Do not use write/read counters for "global" parameters. Fixes device const & SSBO issues.
2017-02-05 09:50:14 +00:00
{
CompilerMSL declare threadgroup variables accessed in called functions.
2018-01-24 20:38:17 +00:00
auto &arg = args[arg_idx];
assert(arg.alias_global_variable);
// If the underlying variable needs to be declared
// (ie. a local variable with deferred declaration), do so now.
uint32_t var_id = get<SPIRVariable>(arg.id).basevariable;
if (var_id)
flush_variable_declaration(var_id);
MSL: Fix naming issue of aliased global variables. When the name of an alias global variable collides with a global declaration, MSL would emit inconsistent names, sometimes with the naming fix, sometimes without, because names were being tracked in two separate meta blocks. Fix this by always redirecting parameter naming to the original base variable as necessary.
2018-08-27 07:59:55 +00:00
MSL: Add support for sampler Y'CbCr conversion. This change introduces functions and in one case, a class, to support the `VK_KHR_sampler_ycbcr_conversion` extension. Except in the case of GBGR8 and BGRG8 formats, for which Metal natively supports implicit chroma reconstruction, we're on our own here. We have to do everything ourselves. Much of the complexity comes from the need to support multiple planes, which must now be passed to functions that use the corresponding combined image-samplers. The rest is from the actual Y'CbCr conversion itself, which requires additional post-processing of the sample retrieved from the image. Passing sampled images to a function was a particular problem. To support this, I've added a new class which is emitted to MSL shaders that pass sampled images with Y'CbCr conversions attached around. It can handle sampled images with or without Y'CbCr conversion. This is an awful abomination that should not exist, but I'm worried that there's some shader out there which does this. This support requires Metal 2.0 to work properly, because it uses default-constructed texture objects, which were only added in MSL 2. I'm not even going to get into arrays of combined image-samplers--that's a whole other can of worms. They are deliberately unsupported in this change. I've taken the liberty of refactoring the support for texture swizzling while I'm at it. It's now treated as a post-processing step similar to Y'CbCr conversion. I'd like to think this is cleaner than having everything in `to_function_name()`/`to_function_args()`. It still looks really hairy, though. I did, however, get rid of the explicit type arguments to `spvGatherSwizzle()`/`spvGatherCompareSwizzle()`. Update the C API. In addition to supporting this new functionality, add some compiler options that I added in previous changes, but for which I neglected to update the C API.
2019-08-02 20:11:19 +00:00
arglist.push_back(to_func_call_arg(arg, arg.id));
Do not use write/read counters for "global" parameters. Fixes device const & SSBO issues.
2017-02-05 09:50:14 +00:00
}
For MSL, extract global var refs from within functions and convert them to function args.
2016-07-06 20:55:45 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::to_member_name(const SPIRType &type, uint32_t index)
{
Do not consider aliased struct types if the master is not a block. It is possible for a shader to declare two plain struct types which simply share the same OpName without there being an implicit value/buffer alias relationship. For to_member_name(), make sure to use the type alias master when resolving member names. The member name may be different in a type alias master if the SPIR-V is being intentionally difficult.
2019-10-07 08:31:42 +00:00
if (type.type_alias != TypeID(0) &&
!has_extended_decoration(type.type_alias, SPIRVCrossDecorationBufferBlockRepacked))
{
return to_member_name(get<SPIRType>(type.type_alias), index);
}
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &memb = ir.meta[type.self].members;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (index < memb.size() && !memb[index].alias.empty())
return memb[index].alias;
else
Use _m* for member names without OpMemberName. Member names could conflict with type names in stripped modules with very large structs.
2017-07-29 19:44:20 +00:00
return join("_m", index);
Initial commit.
2016-03-02 17:09:16 +00:00
}
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
string CompilerGLSL::to_member_reference(uint32_t, const SPIRType &type, uint32_t index, bool)
MSL: Expand arrays of buffers passed as input. Even as of Metal 2.1, MSL still doesn't support arrays of buffers directly. Therefore, we must manually expand them. In the prologue, we define arrays holding the argument pointers; these arrays are what the transpiled code ends up referencing. We might be able to do similar things for textures and samplers prior to MSL 2.0. Speaking of which, also enable texture arrays on iOS MSL 1.2.
2018-09-27 01:06:05 +00:00
{
return join(".", to_member_name(type, index));
}
GLSL: Support multi-level struct flattening for I/O.
2020-07-03 11:12:05 +00:00
string CompilerGLSL::to_multi_member_reference(const SPIRType &type, const SmallVector<uint32_t> &indices)
{
string ret;
auto *member_type = &type;
for (auto &index : indices)
{
ret += join(".", to_member_name(*member_type, index));
member_type = &get<SPIRType>(member_type->member_types[index]);
}
return ret;
}
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
void CompilerGLSL::add_member_name(SPIRType &type, uint32_t index)
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &memb = ir.meta[type.self].members;
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
if (index < memb.size() && !memb[index].alias.empty())
{
auto &name = memb[index].alias;
if (name.empty())
return;
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
ParsedIR::sanitize_identifier(name, true, true);
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
update_name_cache(type.member_name_cache, name);
}
}
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
// Checks whether the ID is a row_major matrix that requires conversion before use
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
bool CompilerGLSL::is_non_native_row_major_matrix(uint32_t id)
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
{
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
// Natively supported row-major matrices do not need to be converted.
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
// Legacy targets do not support row major.
if (backend.native_row_major_matrix && !is_legacy())
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
return false;
GLSL: Use need_transpose when checking for non-native matrix.
2020-10-14 14:07:10 +00:00
auto *e = maybe_get<SPIRExpression>(id);
if (e)
return e->need_transpose;
else
return has_decoration(id, DecorationRowMajor);
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
}
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
// Checks whether the member is a row_major matrix that requires conversion before use
bool CompilerGLSL::member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index)
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
{
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
// Natively supported row-major matrices do not need to be converted.
Improvements to legacy GLSL output. - By default, emit uniform structs for UBOs, like push constant. - Forward transpose information, and optimize transpose(matrix) * vector to vector * matrix.
2017-01-13 15:31:13 +00:00
if (backend.native_row_major_matrix && !is_legacy())
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
return false;
// Non-matrix or column-major matrix types do not need to be converted.
Fix case where a struct is loaded which contains a row-major matrix.
2019-02-20 11:19:00 +00:00
if (!has_member_decoration(type.self, index, DecorationRowMajor))
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
return false;
// Only square row-major matrices can be converted at this time.
// Converting non-square matrices will require defining custom GLSL function that
// swaps matrix elements while retaining the original dimensional form of the matrix.
const auto mbr_type = get<SPIRType>(type.member_types[index]);
if (mbr_type.columns != mbr_type.vecsize)
Rework after review
2016-12-15 19:46:10 +00:00
SPIRV_CROSS_THROW("Row-major matrices must be square on this platform.");
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
return true;
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
}
Fix some typos in comments.
2019-07-24 10:14:19 +00:00
// Checks if we need to remap physical type IDs when declaring the type in a buffer.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
bool CompilerGLSL::member_is_remapped_physical_type(const SPIRType &type, uint32_t index) const
{
return has_extended_member_decoration(type.self, index, SPIRVCrossDecorationPhysicalTypeID);
}
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
// Checks whether the member is in packed data type, that might need to be unpacked.
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
bool CompilerGLSL::member_is_packed_physical_type(const SPIRType &type, uint32_t index) const
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
{
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
return has_extended_member_decoration(type.self, index, SPIRVCrossDecorationPhysicalTypePacked);
spirv_msl unpack packed MSL uniform struct members. spirv_glsl add member_is_packed_type() and unpack_expression_type() functions.
2017-03-01 18:07:40 +00:00
}
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
// Wraps the expression string in a function call that converts the
// row_major matrix result of the expression to a column_major matrix.
// Base implementation uses the standard library transpose() function.
// Subclasses may override to use a different function.
Run format_all.sh.
2019-07-23 10:23:41 +00:00
string CompilerGLSL::convert_row_major_matrix(string exp_str, const SPIRType &exp_type, uint32_t /* physical_type_id */,
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
bool /*is_packed*/, bool relaxed)
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
{
strip_enclosed_expression(exp_str);
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
if (!is_matrix(exp_type))
{
auto column_index = exp_str.find_last_of('[');
if (column_index == string::npos)
return exp_str;
auto column_expr = exp_str.substr(column_index);
exp_str.resize(column_index);
MSL: Support std140 half matrices and arrays. Super awkward since there is no clean way to express this.
2023-11-27 12:36:49 +00:00
auto end_deferred_index = column_expr.find_last_of(']');
if (end_deferred_index != string::npos && end_deferred_index + 1 != column_expr.size())
{
// If we have any data member fixups, it must be transposed so that it refers to this index.
// E.g. [0].data followed by [1] would be shuffled to [1][0].data which is wrong,
// and needs to be [1].data[0] instead.
end_deferred_index++;
column_expr = column_expr.substr(end_deferred_index) +
column_expr.substr(0, end_deferred_index);
}
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
auto transposed_expr = type_to_glsl_constructor(exp_type) + "(";
Fix some typos in comments.
2019-07-24 10:14:19 +00:00
// Loading a column from a row-major matrix. Unroll the load.
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
for (uint32_t c = 0; c < exp_type.vecsize; c++)
{
transposed_expr += join(exp_str, '[', c, ']', column_expr);
if (c + 1 < exp_type.vecsize)
transposed_expr += ", ";
}
transposed_expr += ")";
return transposed_expr;
}
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
else if (options.version < 120)
{
// GLSL 110, ES 100 do not have transpose(), so emulate it. Note that
// these GLSL versions do not support non-square matrices.
if (exp_type.vecsize == 2 && exp_type.columns == 2)
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
require_polyfill(PolyfillTranspose2x2, relaxed);
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
else if (exp_type.vecsize == 3 && exp_type.columns == 3)
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
require_polyfill(PolyfillTranspose3x3, relaxed);
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
else if (exp_type.vecsize == 4 && exp_type.columns == 4)
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
require_polyfill(PolyfillTranspose4x4, relaxed);
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
else
SPIRV_CROSS_THROW("Non-square matrices are not supported in legacy GLSL, cannot transpose.");
GLSL: Legacy matrix inverse/determinant polyfills, outerProduct() Also refactors polyfill mechanism in GLSL and fixes transpose() lowering precision.
2023-01-26 19:21:27 +00:00
return join("spvTranspose", (options.es && relaxed) ? "MP" : "", "(", exp_str, ")");
GLSL: implement transpose() in GLSL 1.10 / ES 1.00
2020-11-05 16:09:33 +00:00
}
MSL: Support storing to row-major column. Defer transposes to actual Load or Store.
2019-07-22 09:13:44 +00:00
else
return join("transpose(", exp_str, ")");
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
}
Avoid ugly workaround for separate shadow samplers in GLSL/HLSL.
2017-06-17 08:54:59 +00:00
string CompilerGLSL::variable_decl(const SPIRType &type, const string &name, uint32_t id)
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
{
Avoid ugly workaround for separate shadow samplers in GLSL/HLSL.
2017-06-17 08:54:59 +00:00
string type_name = type_to_glsl(type, id);
Document variable type remap interface a bit more. Fix some minor missing pieces from C++. Type remapping like this doesn't seem to fit MSL backend so well, as it does a lot of remapping internally on its own. Type name remapping, really is for fringe extension cases in GLSL which aren't yet supported in SPIR-V.
2016-09-20 08:55:09 +00:00
remap_variable_type_name(type, name, type_name);
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
return join(type_name, " ", name, type_to_array_glsl(type, id));
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
}
MSL: Test that we can mask location writes in TESC.
2021-04-06 13:50:02 +00:00
bool CompilerGLSL::variable_decl_is_remapped_storage(const SPIRVariable &var, StorageClass storage) const
MSL: Emit threadgroup storage class for masked control point outputs. Shader can still rely on writes to threadgroup memory to be visible.
2021-03-26 16:23:44 +00:00
{
MSL: Test that we can mask location writes in TESC.
2021-04-06 13:50:02 +00:00
return var.storage == storage;
MSL: Emit threadgroup storage class for masked control point outputs. Shader can still rely on writes to threadgroup memory to be visible.
2021-03-26 16:23:44 +00:00
}
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
// Emit a structure member. Subclasses may override to modify output,
// or to dynamically add a padding member if needed.
Updates to MSL functionality to support PR review feedback.
2017-03-11 17:17:22 +00:00
void CompilerGLSL::emit_struct_member(const SPIRType &type, uint32_t member_type_id, uint32_t index,
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
const string &qualifier, uint32_t)
Initial commit.
2016-03-02 17:09:16 +00:00
{
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
auto &membertype = get<SPIRType>(member_type_id);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
Bitset memberflags;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
auto &memb = ir.meta[type.self].members;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (index < memb.size())
memberflags = memb[index].decoration_flags;
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
string qualifiers;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
bool is_block = ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) ||
ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
if (is_block)
qualifiers = to_interpolation_qualifiers(memberflags);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
statement(layout_for_member(type, index), qualifiers, qualifier, flags_to_qualifiers_glsl(membertype, memberflags),
spirv_msl auto-alignment of members of MSL uniform structs. spirv_msl optionally add padding and packing to allow MSL struct members to align with SPIR-V struct alignments. spirv_cross add convenience methods for testing Decorations. spirv_glsl replace member_decl() function with new emit_stuct_member(). Allow struct member types to be marked as packed via DecorationCPacked decoration.
2017-03-01 02:44:36 +00:00
variable_decl(membertype, to_member_name(type, index)), ";");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Tests run clean.
2019-07-22 08:23:39 +00:00
void CompilerGLSL::emit_struct_padding_target(const SPIRType &)
{
}
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
string CompilerGLSL::flags_to_qualifiers_glsl(const SPIRType &type, const Bitset &flags)
Initial commit.
2016-03-02 17:09:16 +00:00
{
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
// GL_EXT_buffer_reference variables can be marked as restrict.
if (flags.get(DecorationRestrictPointerEXT))
return "restrict ";
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
string qual;
GLSL: Emit precise for fp16/fp64 types as well.
2021-07-26 20:05:55 +00:00
if (type_is_floating_point(type) && flags.get(DecorationNoContraction) && backend.support_precise_qualifier)
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
qual = "precise ";
GLSL: Emit precise for fp16/fp64 types as well.
2021-07-26 20:05:55 +00:00
// Structs do not have precision qualifiers, neither do doubles (desktop only anyways, so no mediump/highp).
bool type_supports_precision =
type.basetype == SPIRType::Float || type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt ||
type.basetype == SPIRType::Image || type.basetype == SPIRType::SampledImage ||
type.basetype == SPIRType::Sampler;
if (!type_supports_precision)
return qual;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (options.es)
{
Add support for multiple entry points. - Only consider I/O variables if part of OpEntryPoint. - Keep a safe fallback if #entry-points is 1 to avoid potentially breaking previously working shaders.
2016-07-28 09:16:02 +00:00
auto &execution = get_entry_point();
Only use lowp path for legacy ES
2023-11-16 13:00:48 +00:00
if (type.basetype == SPIRType::UInt && is_legacy_es())
Review nit, update brace placement
2023-11-16 13:00:00 +00:00
{
Workaround for generating bool uniforms in ESSL1 Fixes #2223.
2023-11-13 23:23:36 +00:00
// HACK: This is a bool. See comment in type_to_glsl().
qual += "lowp ";
}
else if (flags.get(DecorationRelaxedPrecision))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
bool implied_fmediump = type.basetype == SPIRType::Float &&
options.fragment.default_float_precision == Options::Mediump &&
execution.model == ExecutionModelFragment;
bool implied_imediump = (type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt) &&
options.fragment.default_int_precision == Options::Mediump &&
execution.model == ExecutionModelFragment;
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
qual += (implied_fmediump || implied_imediump) ? "" : "mediump ";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
bool implied_fhighp =
type.basetype == SPIRType::Float && ((options.fragment.default_float_precision == Options::Highp &&
execution.model == ExecutionModelFragment) ||
(execution.model != ExecutionModelFragment));
bool implied_ihighp = (type.basetype == SPIRType::Int || type.basetype == SPIRType::UInt) &&
((options.fragment.default_int_precision == Options::Highp &&
execution.model == ExecutionModelFragment) ||
(execution.model != ExecutionModelFragment));
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
qual += (implied_fhighp || implied_ihighp) ? "" : "highp ";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
Support mediump in desktop Vulkan GLSL.
2017-12-06 09:25:30 +00:00
else if (backend.allow_precision_qualifiers)
{
// Vulkan GLSL supports precision qualifiers, even in desktop profiles, which is convenient.
// The default is highp however, so only emit mediump in the rare case that a shader has these.
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationRelaxedPrecision))
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
qual += "mediump ";
Support mediump in desktop Vulkan GLSL.
2017-12-06 09:25:30 +00:00
}
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
return qual;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
string CompilerGLSL::to_precision_qualifiers_glsl(uint32_t id)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
auto &type = expression_type(id);
Honor NoContraction qualifier. We'll need to force a temporary and mark it as precise. MSL is a little weird here, but we can piggyback on top of the invariant float math option here to force fma() operations everywhere.
2021-05-07 10:28:08 +00:00
bool use_precision_qualifiers = backend.allow_precision_qualifiers;
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
if (use_precision_qualifiers && (type.basetype == SPIRType::Image || type.basetype == SPIRType::SampledImage))
{
// Force mediump for the sampler type. We cannot declare 16-bit or smaller image types.
auto &result_type = get<SPIRType>(type.image.type);
if (result_type.width < 32)
return "mediump ";
}
return flags_to_qualifiers_glsl(type, ir.meta[id].decoration.decoration_flags);
Initial commit.
2016-03-02 17:09:16 +00:00
}
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
void CompilerGLSL::fixup_io_block_patch_primitive_qualifiers(const SPIRVariable &var)
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
{
// Works around weird behavior in glslangValidator where
// a patch out block is translated to just block members getting the decoration.
// To make glslang not complain when we compile again, we have to transform this back to a case where
// the variable itself has Patch decoration, and not members.
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
// Same for perprimitiveEXT.
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
auto &type = get<SPIRType>(var.basetype);
if (has_decoration(type.self, DecorationBlock))
{
uint32_t member_count = uint32_t(type.member_types.size());
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
Decoration promoted_decoration = {};
bool do_promote_decoration = false;
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
for (uint32_t i = 0; i < member_count; i++)
{
if (has_member_decoration(type.self, i, DecorationPatch))
{
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
promoted_decoration = DecorationPatch;
do_promote_decoration = true;
break;
}
else if (has_member_decoration(type.self, i, DecorationPerPrimitiveEXT))
{
promoted_decoration = DecorationPerPrimitiveEXT;
do_promote_decoration = true;
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
break;
}
}
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
if (do_promote_decoration)
{
set_decoration(var.self, promoted_decoration);
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
for (uint32_t i = 0; i < member_count; i++)
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
unset_member_decoration(type.self, i, promoted_decoration);
}
GLSL: Handle some extreme edge cases in Output variable initialization. Deal with patch blocks, arrays of patch blocks, arrays of blocks, etc.
2021-01-04 15:48:35 +00:00
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::to_qualifiers_glsl(uint32_t id)
{
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
auto &flags = get_decoration_bitset(id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string res;
auto *var = maybe_get<SPIRVariable>(id);
if (var && var->storage == StorageClassWorkgroup && !backend.shared_is_implied)
res += "shared ";
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
else if (var && var->storage == StorageClassTaskPayloadWorkgroupEXT && !backend.shared_is_implied)
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
res += "taskPayloadSharedEXT ";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += to_interpolation_qualifiers(flags);
Emit storage qualifier in the correct place. Need to emit qualifiers in a specific order for legacy GLSL. <interpolation> <storage> <precision> <type>.
2017-02-24 08:56:17 +00:00
if (var)
res += to_storage_qualifiers_glsl(*var);
Fix declaration of coherent images.
2017-08-29 13:52:59 +00:00
auto &type = expression_type(id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (type.image.dim != DimSubpassData && type.image.sampled == 2)
{
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationCoherent))
Fix declaration of coherent images.
2017-08-29 13:52:59 +00:00
res += "coherent ";
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationRestrict))
Add restrict qualifier for images.
2017-08-29 13:54:22 +00:00
res += "restrict ";
GLSL: Support GL_EXT_shader_image_load_formatted.
2021-04-20 11:32:41 +00:00
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationNonWritable))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res += "readonly ";
GLSL: Support GL_EXT_shader_image_load_formatted.
2021-04-20 11:32:41 +00:00
bool formatted_load = type.image.format == ImageFormatUnknown;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationNonReadable))
GLSL: Support GL_EXT_shader_image_load_formatted.
2021-04-20 11:32:41 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res += "writeonly ";
GLSL: Support GL_EXT_shader_image_load_formatted.
2021-04-20 11:32:41 +00:00
formatted_load = false;
}
if (formatted_load)
{
if (!options.es)
require_extension_internal("GL_EXT_shader_image_load_formatted");
else
SPIRV_CROSS_THROW("Cannot use GL_EXT_shader_image_load_formatted in ESSL.");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Fix declaration of coherent images.
2017-08-29 13:52:59 +00:00
res += to_precision_qualifiers_glsl(id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return res;
Initial commit.
2016-03-02 17:09:16 +00:00
}
string CompilerGLSL::argument_decl(const SPIRFunction::Parameter &arg)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// glslangValidator seems to make all arguments pointer no matter what which is rather bizarre ...
auto &type = expression_type(arg.id);
const char *direction = "";
if (type.pointer)
{
if (arg.write_count && arg.read_count)
direction = "inout ";
else if (arg.write_count)
direction = "out ";
}
Avoid ugly workaround for separate shadow samplers in GLSL/HLSL.
2017-06-17 08:54:59 +00:00
return join(direction, to_qualifiers_glsl(arg.id), variable_decl(type, to_name(arg.id), arg.id));
Initial commit.
2016-03-02 17:09:16 +00:00
}
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
string CompilerGLSL::to_initializer_expression(const SPIRVariable &var)
{
MSL: Support more usecases for unpacked vectors. Additional usecases include array and vector indexing, variable declarations, loop initializers, function return values, switch statement evaluations, and various specialized MSL operations. Ultimately, we might consider refactoring CompilerMSL::to_expression() to always take into consideration possible unpacking behavior. Refactor CompilerGLSL::to_enclosed_unpacked_expression() for conciseness and consistency with similar functionality.
2021-10-21 20:11:33 +00:00
return to_unpacked_expression(var.initializer);
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
}
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
string CompilerGLSL::to_zero_initialized_expression(uint32_t type_id)
{
#ifndef NDEBUG
auto &type = get<SPIRType>(type_id);
assert(type.storage == StorageClassPrivate || type.storage == StorageClassFunction ||
type.storage == StorageClassGeneric);
#endif
uint32_t id = ir.increase_bound_by(1);
ir.make_constant_null(id, type_id, false);
return constant_expression(get<SPIRConstant>(id));
}
bool CompilerGLSL::type_can_zero_initialize(const SPIRType &type) const
{
if (type.pointer)
return false;
if (!type.array.empty() && options.flatten_multidimensional_arrays)
return false;
for (auto &literal : type.array_size_literal)
if (!literal)
return false;
for (auto &memb : type.member_types)
if (!type_can_zero_initialize(get<SPIRType>(memb)))
return false;
return true;
}
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::variable_decl(const SPIRVariable &variable)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Ignore the pointer type since GLSL doesn't have pointers.
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
auto &type = get_variable_data_type(variable);
Declare variables and parameters with samplerShadow if necessary.
2017-05-06 11:35:02 +00:00
MSL: Deal with pointer-to-pointer qualifier ordering.
2021-02-26 11:50:24 +00:00
if (type.pointer_depth > 1 && !backend.support_pointer_to_pointer)
Keep track of pointer-to-pointer depth in parser. Defer failure of pointer-to-pointer to compilation time, so we can still reflect VK_KHR_variable_pointer shaders.
2018-11-26 11:23:28 +00:00
SPIRV_CROSS_THROW("Cannot declare pointer-to-pointer types.");
Run format_all.sh.
2017-06-17 08:56:24 +00:00
auto res = join(to_qualifiers_glsl(variable.self), variable_decl(type, to_name(variable.self), variable.self));
Declare variables and parameters with samplerShadow if necessary.
2017-05-06 11:35:02 +00:00
Check if a loop variable candidate is actually used. Phi nodes used in continue blocks are not always loop variables. Fix by checking if path from dominator to loop header has some variable use.
2018-01-23 19:27:43 +00:00
if (variable.loop_variable && variable.static_expression)
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
{
uint32_t expr = variable.static_expression;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (ir.ids[expr].get_type() != TypeUndef)
MSL: Support more usecases for unpacked vectors. Additional usecases include array and vector indexing, variable declarations, loop initializers, function return values, switch statement evaluations, and various specialized MSL operations. Ultimately, we might consider refactoring CompilerMSL::to_expression() to always take into consideration possible unpacking behavior. Refactor CompilerGLSL::to_enclosed_unpacked_expression() for conciseness and consistency with similar functionality.
2021-10-21 20:11:33 +00:00
res += join(" = ", to_unpacked_expression(variable.static_expression));
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
else if (options.force_zero_initialized_variables && type_can_zero_initialize(type))
res += join(" = ", to_zero_initialized_expression(get_variable_data_type_id(variable)));
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
}
MSL: Fix initialization of masked threadgroup variables.
2021-04-14 09:27:05 +00:00
else if (variable.initializer && !variable_decl_is_remapped_storage(variable, StorageClassWorkgroup))
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
{
uint32_t expr = variable.initializer;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (ir.ids[expr].get_type() != TypeUndef)
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
res += join(" = ", to_initializer_expression(variable));
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
else if (options.force_zero_initialized_variables && type_can_zero_initialize(type))
res += join(" = ", to_zero_initialized_expression(get_variable_data_type_id(variable)));
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
}
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return res;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
const char *CompilerGLSL::to_pls_qualifiers_glsl(const SPIRVariable &variable)
Initial commit.
2016-03-02 17:09:16 +00:00
{
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
auto &flags = get_decoration_bitset(variable.self);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationRelaxedPrecision))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "mediump ";
else
return "highp ";
Initial commit.
2016-03-02 17:09:16 +00:00
}
string CompilerGLSL::pls_decl(const PlsRemap &var)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &variable = get<SPIRVariable>(var.id);
Initial commit.
2016-03-02 17:09:16 +00:00
Added an Op field to SPIRType This field allows telling what the 'head' of the type is, without having to look at parent types.
2023-11-30 11:28:50 +00:00
auto op_and_basetype = pls_format_to_basetype(var.format);
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType type { op_and_basetype.first };
type.basetype = op_and_basetype.second;
Added an Op field to SPIRType This field allows telling what the 'head' of the type is, without having to look at parent types.
2023-11-30 11:28:50 +00:00
auto vecsize = pls_format_to_components(var.format);
if (vecsize > 1)
{
type.op = OpTypeVector;
type.vecsize = vecsize;
}
Initial commit.
2016-03-02 17:09:16 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return join(to_pls_layout(var.format), to_pls_qualifiers_glsl(variable), type_to_glsl(type), " ",
to_name(variable.self));
Initial commit.
2016-03-02 17:09:16 +00:00
}
Deal with OpSpecConstantOp used as array size. When trying to validate buffer sizes, we usually need to bail out when using SpecConstantOps, but for some very specific cases where we allow unsized arrays currently, we can safely allow "unknown" sized arrays as well. This is probably the best we can do, when we have even more difficult cases than this, we throw a more sensible error message.
2018-11-01 13:56:25 +00:00
uint32_t CompilerGLSL::to_array_size_literal(const SPIRType &type) const
{
return to_array_size_literal(type, uint32_t(type.array.size() - 1));
}
Support arrays which have spec constant size. The size of an array can be a specialization constant or a spec constant op. This complicates things quite a lot. Reflection becomes very painful in the presence of expressions instead of literals so add a new array which expresses this. It is unlikely that we will need to do accurate reflection of interface types which have specialization constant size. SSBOs and UBOs will for now throw exception if a dynamic size is used since it is very difficult to know the real size.
2016-10-03 15:17:11 +00:00
uint32_t CompilerGLSL::to_array_size_literal(const SPIRType &type, uint32_t index) const
{
assert(type.array.size() == type.array_size_literal.size());
Support spec constant array size in blocks. Won't really be correct if the spec constant is changed outside SPIRV-Cross, but nothing we can do about that, really.
2018-02-23 14:09:28 +00:00
if (type.array_size_literal[index])
{
return type.array[index];
}
else
{
// Use the default spec constant value.
// This is the best we can do.
Implement a simple evaluator of specialization constants. In some cases, we need to get a literal value from a spec constant op. Mostly relevant when emitting buffers, so implement a 32-bit integer scalar subset of the evaluator. Can be extended as needed to support evaluating any specialization constant operation.
2020-09-14 08:42:31 +00:00
return evaluate_constant_u32(type.array[index]);
Support spec constant array size in blocks. Won't really be correct if the spec constant is changed outside SPIRV-Cross, but nothing we can do about that, really.
2018-02-23 14:09:28 +00:00
}
Support arrays which have spec constant size. The size of an array can be a specialization constant or a spec constant op. This complicates things quite a lot. Reflection becomes very painful in the presence of expressions instead of literals so add a new array which expresses this. It is unlikely that we will need to do accurate reflection of interface types which have specialization constant size. SSBOs and UBOs will for now throw exception if a dynamic size is used since it is very difficult to know the real size.
2016-10-03 15:17:11 +00:00
}
string CompilerGLSL::to_array_size(const SPIRType &type, uint32_t index)
{
assert(type.array.size() == type.array_size_literal.size());
auto &size = type.array[index];
if (!type.array_size_literal[index])
return to_expression(size);
else if (size)
return convert_to_string(size);
HLSL/MSL: Deal correctly with nonuniformEXT qualifier. MSL does not seem to have a qualifier for this, but HLSL SM 5.1 does. glslangValidator for HLSL does not support this, so skip any validation, but it passes in FXC.
2019-05-13 12:58:27 +00:00
else if (!backend.unsized_array_supported)
Support arrays which have spec constant size. The size of an array can be a specialization constant or a spec constant op. This complicates things quite a lot. Reflection becomes very painful in the presence of expressions instead of literals so add a new array which expresses this. It is unlikely that we will need to do accurate reflection of interface types which have specialization constant size. SSBOs and UBOs will for now throw exception if a dynamic size is used since it is very difficult to know the real size.
2016-10-03 15:17:11 +00:00
{
// For runtime-sized arrays, we can work around
// lack of standard support for this by simply having
// a single element array.
//
// Runtime length arrays must always be the last element
// in an interface block.
return "1";
}
else
return "";
}
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
string CompilerGLSL::type_to_array_glsl(const SPIRType &type, uint32_t)
Initial commit.
2016-03-02 17:09:16 +00:00
{
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
if (type.pointer && type.storage == StorageClassPhysicalStorageBufferEXT && type.basetype != SPIRType::Struct)
{
// We are using a wrapped pointer type, and we should not emit any array declarations here.
return "";
}
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
if (type.array.empty())
return "";
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
if (options.flatten_multidimensional_arrays)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
string res;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res += "[";
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
for (auto i = uint32_t(type.array.size()); i; i--)
{
res += enclose_expression(to_array_size(type, i - 1));
if (i > 1)
res += " * ";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res += "]";
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
return res;
}
else
{
if (type.array.size() > 1)
{
if (!options.es && options.version < 430)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_arrays_of_arrays");
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
else if (options.es && options.version < 310)
Add multidimensional array flattening test.
2017-05-22 15:40:00 +00:00
SPIRV_CROSS_THROW("Arrays of arrays not supported before ESSL version 310. "
"Try using --flatten-multidimensional-arrays or set "
"options.flatten_multidimensional_arrays to true.");
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
}
string res;
for (auto i = uint32_t(type.array.size()); i; i--)
{
res += "[";
res += to_array_size(type, i - 1);
res += "]";
}
return res;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
MSL: Plumb through member state to image/sampler types.
2024-01-05 14:15:41 +00:00
string CompilerGLSL::image_type_glsl(const SPIRType &type, uint32_t id, bool /*member*/)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &imagetype = get<SPIRType>(type.image.type);
string res;
switch (imagetype.basetype)
{
GLSL: Implement 64-bit image support.
2023-08-17 10:17:37 +00:00
case SPIRType::Int64:
res = "i64";
require_extension_internal("GL_EXT_shader_image_int64");
break;
case SPIRType::UInt64:
res = "u64";
require_extension_internal("GL_EXT_shader_image_int64");
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Int:
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
case SPIRType::Short:
case SPIRType::SByte:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res = "i";
break;
case SPIRType::UInt:
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
case SPIRType::UShort:
case SPIRType::UByte:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res = "u";
break;
default:
break;
}
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
// For half image types, we will force mediump for the sampler, and cast to f16 after any sampling operation.
// We cannot express a true half texture type in GLSL. Neither for short integer formats for that matter.
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData && options.vulkan_semantics)
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
return res + "subpassInput" + (type.image.ms ? "MS" : "");
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
else if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData &&
subpass_input_is_framebuffer_fetch(id))
{
SPIRType sampled_type = get<SPIRType>(type.image.type);
sampled_type.vecsize = 4;
return type_to_glsl(sampled_type);
}
Add support for Vulkan GLSL as output target. Mostly useful for debugging SPIR-V where it is useful to see the "original" Vulkan GLSL constructs which created the SPIR-V.
2016-05-05 08:16:22 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// If we're emulating subpassInput with samplers, force sampler2D
// so we don't have to specify format.
if (type.basetype == SPIRType::Image && type.image.dim != DimSubpassData)
Fix case where samplerBuffer is emitted without combined sampler.
2017-04-02 08:54:11 +00:00
{
// Sampler buffers are always declared as samplerBuffer even though they might be separate images in the SPIR-V.
if (type.image.dim == DimBuffer && type.image.sampled == 1)
res += "sampler";
else
res += type.image.sampled == 2 ? "image" : "texture";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
res += "sampler";
switch (type.image.dim)
{
case Dim1D:
GLSL: Implement 1D texture emulation for ES. ES does not support 1D images at all. Fake it by promoting 1D images to 2D.
2022-05-27 09:51:34 +00:00
// ES doesn't support 1D. Fake it with 2D.
res += options.es ? "2D" : "1D";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
case Dim2D:
res += "2D";
break;
case Dim3D:
res += "3D";
break;
case DimCube:
res += "Cube";
break;
Added support for sampler2DRect and legacy texture2DRect() sampling function
2019-01-06 20:21:59 +00:00
case DimRect:
if (options.es)
SPIRV_CROSS_THROW("Rectangle textures are not supported on OpenGL ES.");
if (is_legacy_desktop())
require_extension_internal("GL_ARB_texture_rectangle");
res += "2DRect";
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case DimBuffer:
if (options.es && options.version < 320)
fix: GL_EXT_texture_buffer is more common than GL_OES_texture_buffer
2022-01-10 08:49:45 +00:00
require_extension_internal("GL_EXT_texture_buffer");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (!options.es && options.version < 300)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_EXT_texture_buffer_object");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res += "Buffer";
break;
case DimSubpassData:
res += "2D";
break;
default:
Added support for sampler2DRect and legacy texture2DRect() sampling function
2019-01-06 20:21:59 +00:00
SPIRV_CROSS_THROW("Only 1D, 2D, 2DRect, 3D, Buffer, InputTarget and Cube textures supported.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Implement OpImageQuerySamples.
2016-07-11 10:47:46 +00:00
if (type.image.ms)
res += "MS";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (type.image.arrayed)
For arrayed textures in GLSL < 130, require GL_EXT_texture_array and emit correct texture lookup function names
2016-09-17 08:01:50 +00:00
{
Clean up.
2016-09-17 13:56:23 +00:00
if (is_legacy_desktop())
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_EXT_texture_array");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res += "Array";
For arrayed textures in GLSL < 130, require GL_EXT_texture_array and emit correct texture lookup function names
2016-09-17 08:01:50 +00:00
}
Fix depth image usage in MSL for separate image/samplers.
2018-02-09 11:37:17 +00:00
// "Shadow" state in GLSL only exists for samplers and combined image samplers.
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
if (((type.basetype == SPIRType::SampledImage) || (type.basetype == SPIRType::Sampler)) &&
Separate (partially) the tracking of depth images from depth compare ops. SPIR-V allows an image to be marked as a depth image, but with a non-depth format. Such images should be read or sampled as vectors instead of scalars, except when they are subject to compare operations. Don't mark an OpSampledImage as using a compare operation just because the image contains a depth marker. Instead, require that a compare operation is actually used on that image. Compiler::image_is_comparison() was really testing whether an image is a depth image, since it incorporates the depth marker. Rename that function to is_depth_image(), to clarify what it is really testing. In Compiler::is_depth_image(), do not treat an image as a depth image if it has been explicitly marked with a color format, unless the image is subject to compare operations. In CompilerMSL::to_function_name(), test for compare operations specifically, rather than assuming them from the depth-image marker. CompilerGLSL and CompilerMSL still contain a number of internal tests that use is_depth_image() both for testing for a depth image, and for testing whether compare operations are being used. I've left these as they are for now, but these should be cleaned up at some point. Add unit tests for fetch/sample depth images with color formats and no compare ops.
2021-11-08 20:59:45 +00:00
is_depth_image(type, id))
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
res += "Shadow";
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
if (type.image.dim == DimCube && is_legacy())
{
if (!options.es)
require_extension_internal("GL_EXT_gpu_shader4");
else
{
require_extension_internal("GL_NV_shadow_samplers_cube");
res += "NV";
}
}
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return res;
Initial commit.
2016-03-02 17:09:16 +00:00
}
string CompilerGLSL::type_to_glsl_constructor(const SPIRType &type)
{
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
if (backend.use_array_constructor && type.array.size() > 1)
Check multidimensional extension in type_to_glsl_constructor.
2017-05-22 15:47:03 +00:00
{
if (options.flatten_multidimensional_arrays)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Cannot flatten constructors of multidimensional array constructors, "
"e.g. float[][]().");
Check multidimensional extension in type_to_glsl_constructor.
2017-05-22 15:47:03 +00:00
else if (!options.es && options.version < 430)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_arrays_of_arrays");
Check multidimensional extension in type_to_glsl_constructor.
2017-05-22 15:47:03 +00:00
else if (options.es && options.version < 310)
SPIRV_CROSS_THROW("Arrays of arrays not supported before ESSL version 310.");
}
Add multidimensional array flattening test.
2017-05-22 15:40:00 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto e = type_to_glsl(type);
MSL: Declare arrays with proper type wrapper. Need to construct with value type spvUnsafeArray<T, N>({ elem0, elem1 }) to make array initialization work in complex scenarios.
2019-10-26 15:57:34 +00:00
if (backend.use_array_constructor)
{
for (uint32_t i = 0; i < type.array.size(); i++)
e += "[]";
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return e;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
// The optional id parameter indicates the object whose type we are trying
// to find the description for. It is optional. Most type descriptions do not
// depend on a specific object's use of that type.
string CompilerGLSL::type_to_glsl(const SPIRType &type, uint32_t id)
Initial commit.
2016-03-02 17:09:16 +00:00
{
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
if (is_physical_pointer(type) && !is_physical_pointer_to_buffer_block(type))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
// Need to create a magic type name which compacts the entire type information.
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
auto *parent = &get_pointee_type(type);
string name = type_to_glsl(*parent);
GLSL: Handle ptr-to-array casts with unexpected array strides.
2024-01-18 13:14:10 +00:00
uint32_t array_stride = get_decoration(type.parent_type, DecorationArrayStride);
// Resolve all array dimensions in one go since once we lose the pointer type,
// array information is left to to_array_type_glsl. The base type loses array information.
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
while (is_array(*parent))
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
{
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
if (parent->array_size_literal.back())
name += join(type.array.back(), "_");
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
else
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
name += join("id", type.array.back(), "_");
GLSL: Handle ptr-to-array casts with unexpected array strides.
2024-01-18 13:14:10 +00:00
name += "stride_" + std::to_string(array_stride);
array_stride = get_decoration(parent->parent_type, DecorationArrayStride);
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
parent = &get<SPIRType>(parent->parent_type);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
}
GLSL: Handle BDA to plain non-block struct. The implementation assumed that BDA to struct would always result in a Block-like type, but that is not necessarily the case. Treat non-Block structs as POD types as well.
2024-01-18 11:40:47 +00:00
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
name += "Pointer";
return name;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (type.basetype)
{
case SPIRType::Struct:
// Need OpName lookup here to get a "sensible" name for a struct.
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
if (backend.explicit_struct_type)
return join("struct ", to_name(type.self));
else
return to_name(type.self);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Image:
case SPIRType::SampledImage:
Support emitting SPIR-V type declarations tuned for specified SPIR-V objects. CompilerGLSL type_to_glsl() and image_type_glsl() functions support optional object ID. Add SPIRType::Image::access member to support SPIR-V OpTypeImage access qualifier. Remove SPIRType::Image::is_read and ::is_written members. Use DecorationNonReadable and DecorationNonWritable to mark read/write access for image variables. CompilerMSL emit access qualifiers per image variable, instead of per image type. CompilerGLSL and CompilerHLSL behaviour is unchanged.
2017-05-30 00:45:05 +00:00
return image_type_glsl(type, id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Sampler:
GLSL will also need shadow state analysis. Refactor stuff out to top-level. Fix some bugs with combined shadow samplers in regular GLSL.
2017-05-06 11:21:35 +00:00
// The depth field is set by calling code based on the variable ID of the sampler, effectively reintroducing
// this distinction into the type system.
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
return comparison_ids.count(id) ? "samplerShadow" : "sampler";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Handle RayQueryKHR type. Do not error out in parsing in shaders which use ray queries.
2020-04-21 12:25:18 +00:00
case SPIRType::AccelerationStructure:
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
return ray_tracing_is_khr ? "accelerationStructureEXT" : "accelerationStructureNV";
Add support for SPV_NV_ray_tracing
2019-02-26 14:43:03 +00:00
GLSL: Implement GL_EXT_ray_query.
2021-07-19 11:36:37 +00:00
case SPIRType::RayQuery:
return "rayQueryEXT";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Void:
return "void";
default:
break;
}
Be a bit smarter about uint on legacy targets. Allow constants (array sizes for example), but using unsigned opcodes, and unsigned-specific opcodes is a problem.
2018-04-17 12:56:49 +00:00
if (type.basetype == SPIRType::UInt && is_legacy())
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
{
if (options.es)
Workaround for generating bool uniforms in ESSL1 Fixes #2223.
2023-11-13 23:23:36 +00:00
// HACK: spirv-cross changes bools into uints and generates code which compares them to
// zero. Input code will have already been validated as not to have contained any uints,
// so any remaining uints must in fact be bools. However, simply returning "bool" here
// will result in invalid code. Instead, return an int.
return backend.basic_int_type;
GLSL: Add various additional extension checks.
2023-01-23 10:22:52 +00:00
else
require_extension_internal("GL_EXT_gpu_shader4");
}
if (type.basetype == SPIRType::AtomicCounter)
{
if (options.es && options.version < 310)
SPIRV_CROSS_THROW("At least ESSL 3.10 required for atomic counters.");
else if (!options.es && options.version < 420)
require_extension_internal("GL_ARB_shader_atomic_counters");
}
Be a bit smarter about uint on legacy targets. Allow constants (array sizes for example), but using unsigned opcodes, and unsigned-specific opcodes is a problem.
2018-04-17 12:56:49 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (type.vecsize == 1 && type.columns == 1) // Scalar builtin
{
switch (type.basetype)
{
Use Boolean instead of Bool. Xlib.h header uses a very ugly define for Bool which conflicts with SPIRV-Cross. The hassle free solution is to use Boolean instead.
2016-06-05 18:13:45 +00:00
case SPIRType::Boolean:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return "bool";
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
case SPIRType::SByte:
return backend.basic_int8_type;
case SPIRType::UByte:
return backend.basic_uint8_type;
case SPIRType::Short:
return backend.basic_int16_type;
case SPIRType::UShort:
return backend.basic_uint16_type;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Int:
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
return backend.basic_int_type;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::UInt:
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
return backend.basic_uint_type;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::AtomicCounter:
return "atomic_uint";
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
case SPIRType::Half:
return "float16_t";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Float:
return "float";
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
case SPIRType::Double:
return "double";
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
case SPIRType::Int64:
return "int64_t";
case SPIRType::UInt64:
return "uint64_t";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
return "???";
}
}
else if (type.vecsize > 1 && type.columns == 1) // Vector builtin
{
switch (type.basetype)
{
Use Boolean instead of Bool. Xlib.h header uses a very ugly define for Bool which conflicts with SPIRV-Cross. The hassle free solution is to use Boolean instead.
2016-06-05 18:13:45 +00:00
case SPIRType::Boolean:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return join("bvec", type.vecsize);
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
case SPIRType::SByte:
return join("i8vec", type.vecsize);
case SPIRType::UByte:
return join("u8vec", type.vecsize);
case SPIRType::Short:
return join("i16vec", type.vecsize);
case SPIRType::UShort:
return join("u16vec", type.vecsize);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Int:
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
return join("ivec", type.vecsize);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::UInt:
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
return join("uvec", type.vecsize);
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
case SPIRType::Half:
return join("f16vec", type.vecsize);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Float:
return join("vec", type.vecsize);
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
case SPIRType::Double:
return join("dvec", type.vecsize);
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
case SPIRType::Int64:
return join("i64vec", type.vecsize);
case SPIRType::UInt64:
return join("u64vec", type.vecsize);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
return "???";
}
}
else if (type.vecsize == type.columns) // Simple Matrix builtin
{
switch (type.basetype)
{
Use Boolean instead of Bool. Xlib.h header uses a very ugly define for Bool which conflicts with SPIRV-Cross. The hassle free solution is to use Boolean instead.
2016-06-05 18:13:45 +00:00
case SPIRType::Boolean:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return join("bmat", type.vecsize);
case SPIRType::Int:
return join("imat", type.vecsize);
case SPIRType::UInt:
return join("umat", type.vecsize);
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
case SPIRType::Half:
return join("f16mat", type.vecsize);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Float:
return join("mat", type.vecsize);
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
case SPIRType::Double:
return join("dmat", type.vecsize);
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
// Matrix types not supported for int64/uint64.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
return "???";
}
}
else
{
switch (type.basetype)
{
Use Boolean instead of Bool. Xlib.h header uses a very ugly define for Bool which conflicts with SPIRV-Cross. The hassle free solution is to use Boolean instead.
2016-06-05 18:13:45 +00:00
case SPIRType::Boolean:
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return join("bmat", type.columns, "x", type.vecsize);
case SPIRType::Int:
return join("imat", type.columns, "x", type.vecsize);
case SPIRType::UInt:
return join("umat", type.columns, "x", type.vecsize);
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
case SPIRType::Half:
return join("f16mat", type.columns, "x", type.vecsize);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRType::Float:
return join("mat", type.columns, "x", type.vecsize);
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
case SPIRType::Double:
return join("dmat", type.columns, "x", type.vecsize);
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
// Matrix types not supported for int64/uint64.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
return "???";
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
void CompilerGLSL::add_variable(unordered_set<string> &variables_primary,
const unordered_set<string> &variables_secondary, string &name)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (name.empty())
return;
Overhaul how we deal with reserved identifiers. - Do not silently drop reserved identifiers in the parser. This makes it possible to reflect identifiers which are reserved by the cross-compiler module. - Instead of dropping the name, emit _RESERVED_IDENTIFIER_FIXUP in the source to make it clear that a name has been rewritten. - Document what is reserved and not.
2020-08-21 14:14:13 +00:00
ParsedIR::sanitize_underscores(name);
if (ParsedIR::is_globally_reserved_identifier(name, true))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
name.clear();
return;
}
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
update_name_cache(variables_primary, variables_secondary, name);
Improve handling of block name declaration in GLSL. HLSL UAVs are a bit annoying because they can share block types, so reflection becomes rather awkward. Sometimes we will need to make some nasty fallbacks, so add a reflection interface which lets you query post-shader compile which names was actually declared in the shader.
2017-12-01 13:20:51 +00:00
}
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
void CompilerGLSL::add_local_variable_name(uint32_t id)
{
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
add_variable(local_variable_names, block_names, ir.meta[id].decoration.alias);
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
}
void CompilerGLSL::add_resource_name(uint32_t id)
{
Use correct block-name / other-name aliasing rules. A block name cannot alias with any name in its own scope, and it cannot alias with any other "global" name. To solve this, we need to complicate the name cache updates a little bit where we have a "primary" namespace and "secondary" namespace.
2019-01-04 11:15:43 +00:00
add_variable(resource_names, block_names, ir.meta[id].decoration.alias);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Add explicit support for remapping variables. Will enable use of extensions like framebuffer fetch, last fragment depth and so on.
2016-07-06 07:58:01 +00:00
void CompilerGLSL::add_header_line(const std::string &line)
{
header_lines.push_back(line);
}
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
bool CompilerGLSL::has_extension(const std::string &ext) const
{
auto itr = find(begin(forced_extensions), end(forced_extensions), ext);
return itr != end(forced_extensions);
}
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
void CompilerGLSL::require_extension(const std::string &ext)
{
if (!has_extension(ext))
forced_extensions.push_back(ext);
}
Apply suggestions from code review
2023-06-06 10:41:59 +00:00
const SmallVector<std::string> &CompilerGLSL::get_required_extensions() const
{
added get_required_extensions() API to GLSL compiler
2023-05-26 13:36:28 +00:00
return forced_extensions;
}
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
void CompilerGLSL::require_extension_internal(const string &ext)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
if (backend.supports_extensions && !has_extension(ext))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
forced_extensions.push_back(ext);
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
void CompilerGLSL::flatten_buffer_block(VariableID id)
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
{
auto &var = get<SPIRVariable>(id);
auto &type = get<SPIRType>(var.basetype);
auto name = to_name(type.self, false);
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
auto &flags = get_decoration_bitset(type.self);
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
if (!type.array.empty())
SPIRV_CROSS_THROW(name + " is an array of UBOs.");
if (type.basetype != SPIRType::Struct)
SPIRV_CROSS_THROW(name + " is not a struct.");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (!flags.get(DecorationBlock))
Implement buffer block flattening Legacy GLSL targets do not support uniform buffers, and as such require some sort of emulation. There are two alternatives - one is to represent a uniform buffer as a uniform struct, and another one is to flatten it into an array of primitive vector types (vec4). Uniform struct have two disadvantages that make using them prohibitive in some applications: - The location assignment for struct members is arbitrary which means the application has to set each struct member one by one - Some Android drivers fail to link shader programs if both vertex and fragment shader use the same uniform struct Because of this, we need to support flattening uniform buffers into an array. This is not just important for legacy GLSL but also is sometimes useful for ESSL 3.0 where some Android drivers do not have stable UBO support. The way flattening works is the entire buffer is represented as a vec4 array; each access chain is rewritten into a combination of array accesses, swizzles and data type constructors. Specifically: - Extracting a vector or a scalar requires indexing into the array with an optional swizzle, for example CB0[13].yz for reading vec2 - Extracting a matrix or a struct requires extracting each individual vector or struct member and then combining them into the resulting object - Extracting arrays is not supported, mostly because the resulting construct is very inefficient and ESSL 1.0 does not support array constructors. Additionally, while we try to constant-fold each individual indexing operation, there are cases where we have to use dynamic index computation (specifically for indexing arrays with non-constants); so the general form of the primitive array extraction expression is: buffer[stride0*index0+...+strideN*indexN+offset] Where stride/offset are integer literals and index represents variables.
2016-12-07 05:02:15 +00:00
SPIRV_CROSS_THROW(name + " is not a block.");
if (type.member_types.empty())
SPIRV_CROSS_THROW(name + " is an empty struct.");
flattened_buffer_blocks.insert(id);
}
Simplified overriding of 'access_chain_internal' function in CompilerMSL.
2019-10-22 15:06:16 +00:00
bool CompilerGLSL::builtin_translates_to_nonarray(spv::BuiltIn /*builtin*/) const
{
return false; // GLSL itself does not need to translate array builtin types to non-array builtin types
}
HLSL: Add support to preserve (RW)StructuredBuffer resources.
2023-05-02 21:36:43 +00:00
bool CompilerGLSL::is_user_type_structured(uint32_t /*id*/) const
{
return false; // GLSL itself does not have structured user type, but HLSL does with StructuredBuffer and RWStructuredBuffer resources.
}
Initial commit.
2016-03-02 17:09:16 +00:00
bool CompilerGLSL::check_atomic_image(uint32_t id)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &type = expression_type(id);
if (type.storage == StorageClassImage)
{
if (options.es && options.version < 320)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_OES_shader_image_atomic");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto *var = maybe_get_backing_variable(id);
if (var)
{
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
if (has_decoration(var->self, DecorationNonWritable) || has_decoration(var->self, DecorationNonReadable))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
GLSL: Clean up some ways of querying decoration flags.
2022-04-29 11:47:49 +00:00
unset_decoration(var->self, DecorationNonWritable);
unset_decoration(var->self, DecorationNonReadable);
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
return true;
}
else
return false;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Handle overloaded functions which share the same OpName. Awkward, but legal SPIR-V.
2018-02-23 13:13:46 +00:00
void CompilerGLSL::add_function_overload(const SPIRFunction &func)
{
Hasher hasher;
for (auto &arg : func.arguments)
Fix function overload when SPIR-V overloads on pointer type.
2018-02-25 09:58:22 +00:00
{
// Parameters can vary with pointer type or not,
// but that will not change the signature in GLSL/HLSL,
// so strip the pointer type before hashing.
Rename get_non_pointer_type() methods. This better reflects their purpose now.
2019-01-08 18:54:40 +00:00
uint32_t type_id = get_pointee_type_id(arg.type);
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
auto &type = get<SPIRType>(type_id);
Deal with fake overloads when using combined image samplers.
2018-05-02 08:35:37 +00:00
if (!combined_image_samplers.empty())
{
// If we have combined image samplers, we cannot really trust the image and sampler arguments
// we pass down to callees, because they may be shuffled around.
// Ignore these arguments, to make sure that functions need to differ in some other way
// to be considered different overloads.
CompilerMSL pass builtin struct members into functions. Add and use Compiler::get_non_pointer_type() convenience functions.
2018-06-24 19:06:12 +00:00
if (type.basetype == SPIRType::SampledImage ||
(type.basetype == SPIRType::Image && type.image.sampled == 1) || type.basetype == SPIRType::Sampler)
Deal with fake overloads when using combined image samplers.
2018-05-02 08:35:37 +00:00
{
continue;
}
}
Fix function overload when SPIR-V overloads on pointer type.
2018-02-25 09:58:22 +00:00
hasher.u32(type_id);
}
Handle overloaded functions which share the same OpName. Awkward, but legal SPIR-V.
2018-02-23 13:13:46 +00:00
uint64_t types_hash = hasher.get();
auto function_name = to_name(func.self);
auto itr = function_overloads.find(function_name);
if (itr != end(function_overloads))
{
// There exists a function with this name already.
auto &overloads = itr->second;
if (overloads.count(types_hash) != 0)
{
// Overload conflict, assign a new name.
add_resource_name(func.self);
function_overloads[to_name(func.self)].insert(types_hash);
}
else
{
// Can reuse the name.
overloads.insert(types_hash);
}
}
else
{
// First time we see this function name.
add_resource_name(func.self);
function_overloads[to_name(func.self)].insert(types_hash);
}
}
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
void CompilerGLSL::emit_function_prototype(SPIRFunction &func, const Bitset &return_flags)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (func.self != ir.default_entry_point)
Handle overloaded functions which share the same OpName. Awkward, but legal SPIR-V.
2018-02-23 13:13:46 +00:00
add_function_overload(func);
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
// Avoid shadow declarations.
local_variable_names = resource_names;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
string decl;
auto &type = get<SPIRType>(func.return_type);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
decl += flags_to_qualifiers_glsl(type, return_flags);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
decl += type_to_glsl(type);
Pass down orig_id to type_to_array_glsl as well. Allows UBO/SSBO resources in MSL to get the layout-derived size as well.
2024-05-21 11:41:40 +00:00
decl += type_to_array_glsl(type, 0);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
decl += " ";
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (func.self == ir.default_entry_point)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Deal with complex interlock cases in GLSL.
2019-09-04 10:18:04 +00:00
// If we need complex fallback in GLSL, we just wrap main() in a function
// and interlock the entire shader ...
if (interlocked_is_complex)
decl += "spvMainInterlockedBody";
else
decl += "main";
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
processing_entry_point = true;
}
else
Enhancements to MSL compute and entry point naming. Support Workgroup (threadgroup) variables. Mark if SPIRConstant is used as an array length, since it cannot be specialized. Resolve specialized array length constants. Support passing an array to MSL function. Support emitting GLSL array assignments in MSL via an array copy function. Support for memory and control barriers. Struct packing enhancements, including packing nested structs. Enhancements to replacing illegal MSL variable and function names. Add Compiler::get_entry_point_name_map() function to retrieve entry point renamings. Remove CompilerGLSL::clean_func_name() as obsolete. Fixes to types in bitcast MSL functions. Add Variant::get_id() member function. Add CompilerMSL::Options::msl_version option. Add numerous MSL compute tests.
2017-11-06 02:34:42 +00:00
decl += to_name(func.self);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
decl += "(";
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<string> arglist;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (auto &arg : func.arguments)
{
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
// Do not pass in separate images or samplers if we're remapping
// to combined image samplers.
if (skip_argument(arg.id))
continue;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Might change the variable name if it already exists in this function.
// SPIRV OpName doesn't have any semantic effect, so it's valid for an implementation
// to use same name for variables.
// Since we want to make the GLSL debuggable and somewhat sane, use fallback names for variables which are duplicates.
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
add_local_variable_name(arg.id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
arglist.push_back(argument_decl(arg));
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
// Hold a pointer to the parameter so we can invalidate the readonly field if needed.
auto *var = maybe_get<SPIRVariable>(arg.id);
if (var)
var->parameter = &arg;
}
for (auto &arg : func.shadow_arguments)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
// Might change the variable name if it already exists in this function.
// SPIRV OpName doesn't have any semantic effect, so it's valid for an implementation
// to use same name for variables.
// Since we want to make the GLSL debuggable and somewhat sane, use fallback names for variables which are duplicates.
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
add_local_variable_name(arg.id);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
arglist.push_back(argument_decl(arg));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Hold a pointer to the parameter so we can invalidate the readonly field if needed.
auto *var = maybe_get<SPIRVariable>(arg.id);
if (var)
var->parameter = &arg;
}
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
decl += merge(arglist);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
decl += ")";
statement(decl);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
void CompilerGLSL::emit_function(SPIRFunction &func, const Bitset &return_flags)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Avoid potential cycles.
if (func.active)
return;
func.active = true;
// If we depend on a function, emit that function before we emit our own function.
for (auto block : func.blocks)
{
auto &b = get<SPIRBlock>(block);
for (auto &i : b.ops)
{
auto ops = stream(i);
auto op = static_cast<Op>(i.op);
if (op == OpFunctionCall)
{
// Recursively emit functions which are called.
uint32_t id = ops[2];
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
emit_function(get<SPIRFunction>(id), ir.meta[ops[1]].decoration.decoration_flags);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
}
Support emitting OpLine directive. Facilitates easier mapping from source language to cross-compiled output in tooling.
2019-05-28 11:41:46 +00:00
if (func.entry_line.file_id != 0)
emit_line_directive(func.entry_line.file_id, func.entry_line.line_literal);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_function_prototype(func, return_flags);
begin_scope();
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (func.self == ir.default_entry_point)
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
emit_entry_point_declarations();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
current_function = &func;
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
auto &entry_block = get<SPIRBlock>(func.entry_block);
MSL: Reintroduce workaround for constant arrays being passed by value.
2020-02-24 12:22:52 +00:00
sort(begin(func.constant_arrays_needed_on_stack), end(func.constant_arrays_needed_on_stack));
for (auto &array : func.constant_arrays_needed_on_stack)
{
auto &c = get<SPIRConstant>(array);
auto &type = get<SPIRType>(c.constant_type);
statement(variable_decl(type, join("_", array, "_array_copy")), " = ", constant_expression(c), ";");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
for (auto &v : func.local_variables)
{
auto &var = get<SPIRVariable>(v);
Deal with case where a block is somehow emitted in a duplicated fashion. We seen to have to deal with a case where a block is used multiple times without any "proper" structured control flow, so we risk losing deferred declaration state.
2019-06-05 10:35:30 +00:00
var.deferred_declaration = false;
added task shader support
2024-10-30 23:20:00 +00:00
if (var.storage == StorageClassTaskPayloadWorkgroupEXT)
Minor nits from review.
2024-11-01 10:53:01 +00:00
continue;
Deal with case where a block is somehow emitted in a duplicated fashion. We seen to have to deal with a case where a block is used multiple times without any "proper" structured control flow, so we risk losing deferred declaration state.
2019-06-05 10:35:30 +00:00
MSL: Test that we can mask location writes in TESC.
2021-04-06 13:50:02 +00:00
if (variable_decl_is_remapped_storage(var, StorageClassWorkgroup))
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
{
// Special variable type which cannot have initializer,
// need to be declared as standalone variables.
// Comes from MSL which can push global variables as local variables in main function.
add_local_variable_name(var.self);
statement(variable_decl(var), ";");
var.deferred_declaration = false;
}
Deal with scoping for Private variables.
2018-05-16 08:49:30 +00:00
else if (var.storage == StorageClassPrivate)
{
// These variables will not have had their CFG usage analyzed, so move it to the entry block.
// Comes from MSL which can push global variables as local variables in main function.
// We could just declare them right now, but we would miss out on an important initialization case which is
// LUT declaration in MSL.
// If we don't declare the variable when it is assigned we're forced to go through a helper function
// which copies elements one by one.
add_local_variable_name(var.self);
MSL: Deal correctly with initializers on Private variables. Do not attempt to defer declaration. It would happen to work in most cases, but the edge case is where the first thing that happens to a variable is being OpStore'd into.
2020-04-21 09:20:49 +00:00
if (var.initializer)
{
statement(variable_decl(var), ";");
var.deferred_declaration = false;
}
else
{
auto &dominated = entry_block.dominated_variables;
if (find(begin(dominated), end(dominated), var.self) == end(dominated))
entry_block.dominated_variables.push_back(var.self);
var.deferred_declaration = true;
}
Deal with scoping for Private variables.
2018-05-16 08:49:30 +00:00
}
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
else if (var.storage == StorageClassFunction && var.remapped_variable && var.static_expression)
{
// No need to declare this variable, it has a static expression.
var.deferred_declaration = false;
}
Fix atomic_compare_exchange_weak_explicit. Need to emit a CAS loop. Fix shared memory declaration. Declare atomic ops with correct memory scope.
2018-05-15 14:03:20 +00:00
else if (expression_is_lvalue(v))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
add_local_variable_name(var.self);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Fix duplicated initialization for loop variables with initializers.
2020-06-19 08:51:00 +00:00
// Loop variables should never be declared early, they are explicitly emitted in a loop.
if (var.initializer && !var.loop_variable)
Do not emit storage qualifiers for local variables. Metal backend uses local variables to implement global variables. Do not emit storage qualifiers for any variable which is declared inside a function.
2017-02-24 10:15:34 +00:00
statement(variable_decl_function_local(var), ";");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
{
// Don't declare variable until first use to declutter the GLSL output quite a lot.
// If we don't touch the variable before first branch,
// declare it then since we need variable declaration to be in top scope.
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
var.deferred_declaration = true;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
else
{
Handle empty struct declarations with best effort. This "feature" is a bit icky as we have no useful representation of it, so never emit code which has anything to do with empty structs.
2017-10-06 11:03:34 +00:00
// HACK: SPIR-V in older glslang output likes to use samplers and images as local variables, but GLSL does not allow this.
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
// For these types (non-lvalue), we enforce forwarding through a shadowed variable.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// This means that when we OpStore to these variables, we just write in the expression ID directly.
// This breaks any kind of branching, since the variable must be statically assigned.
// Branching on samplers and images would be pretty much impossible to fake in GLSL.
var.statically_assigned = true;
}
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
var.loop_variable_enable = false;
Cleanup, and make cfg analysis optional.
2016-11-18 16:06:49 +00:00
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
// Loop variables are never declared outside their for-loop, so block any implicit declaration.
if (var.loop_variable)
Handle early reads from loop variables with initializers. Need to consider that static_expression can be 0. Fallback as necessary. Also need to clear the static expression.
2022-04-28 12:36:53 +00:00
{
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
var.deferred_declaration = false;
Handle early reads from loop variables with initializers. Need to consider that static_expression can be 0. Fallback as necessary. Also need to clear the static expression.
2022-04-28 12:36:53 +00:00
// Need to reset the static expression so we can fallback to initializer if need be.
var.static_expression = 0;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Deal with case where a block is somehow emitted in a duplicated fashion. We seen to have to deal with a case where a block is used multiple times without any "proper" structured control flow, so we risk losing deferred declaration state.
2019-06-05 10:35:30 +00:00
// Enforce declaration order for regression testing purposes.
for (auto &block_id : func.blocks)
{
auto &block = get<SPIRBlock>(block_id);
sort(begin(block.dominated_variables), end(block.dominated_variables));
}
Make fixup_hooks more flexible. No reason why it needs to return a string. Callbacks can just do one or more statements themselves.
2018-09-17 12:04:55 +00:00
for (auto &line : current_function->fixup_hooks_in)
line();
CompilerMSL support matrices & arrays in stage-in & stage-out. Support flattening StorageOutput & StorageInput matrices and arrays. No longer move matrix & array inputs to separate buffer. Add separate SPIRFunction::fixup_statements_in & SPIRFunction::fixup_statements_out instead of just SPIRFunction::fixup_statements. Emit SPIRFunction::fixup_statements at beginning of functions. CompilerMSL track vars_needing_early_declaration. Pass global output variables as variables to functions that access them. Sort input structs by location, same as output structs. Emit struct declarations in order output, input, uniforms. Regenerate reference shaders to new formats defined by above.
2018-06-12 15:41:35 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
emit_block_chain(entry_block);
end_scope();
processing_entry_point = false;
statement("");
MSL: Fix regression with Private parameter declaration. If we compile multiple times due to forced_recompile, we had deferred_declaration = true while emitting function prototypes which broke an assumption. Fix this by clearing out stale state before leaving a function.
2019-06-13 08:31:37 +00:00
// Make sure deferred declaration state for local variables is cleared when we are done with function.
// We risk declaring Private/Workgroup variables in places we are not supposed to otherwise.
for (auto &v : func.local_variables)
{
auto &var = get<SPIRVariable>(v);
var.deferred_declaration = false;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::emit_fixup()
{
Allow flip_vert_y in all relevant stages.
2020-09-28 12:09:39 +00:00
if (is_vertex_like_shader())
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Unify vertex clip-coord fixups. The different options were scattered around in different backends and didn't really work right with CLI at all.
2017-08-03 11:02:59 +00:00
if (options.vertex.fixup_clipspace)
{
const char *suffix = backend.float_literal_suffix ? "f" : "";
statement("gl_Position.z = 2.0", suffix, " * gl_Position.z - gl_Position.w;");
}
if (options.vertex.flip_vert_y)
statement("gl_Position.y = -gl_Position.y;");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
void CompilerGLSL::flush_phi(BlockID from, BlockID to)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto &child = get<SPIRBlock>(to);
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
if (child.ignore_phi_from_block == from)
return;
Initial commit.
2016-03-02 17:09:16 +00:00
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
unordered_set<uint32_t> temporary_phi_variables;
for (auto itr = begin(child.phi_variables); itr != end(child.phi_variables); ++itr)
Fix case when Phi variable is a loop variable. Need to flush variable to static expression rather than a variable.
2017-09-25 08:15:17 +00:00
{
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &phi = *itr;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (phi.parent == from)
Fix case when Phi variable is a loop variable. Need to flush variable to static expression rather than a variable.
2017-09-25 08:15:17 +00:00
{
auto &var = get<SPIRVariable>(phi.function_variable);
// A Phi variable might be a loop variable, so flush to static expression.
if (var.loop_variable && !var.loop_variable_enable)
var.static_expression = phi.local_variable;
else
{
flush_variable_declaration(phi.function_variable);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
// Check if we are going to write to a Phi variable that another statement will read from
// as part of another Phi node in our target block.
// For this case, we will need to copy phi.function_variable to a temporary, and use that for future reads.
// This is judged to be extremely rare, so deal with it here using a simple, but suboptimal algorithm.
bool need_saved_temporary =
find_if(itr + 1, end(child.phi_variables), [&](const SPIRBlock::Phi &future_phi) -> bool {
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
return future_phi.local_variable == ID(phi.function_variable) && future_phi.parent == from;
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
}) != end(child.phi_variables);
if (need_saved_temporary)
{
Deal with phi copies which happen inside continue blocks.
2019-01-07 13:19:27 +00:00
// Need to make sure we declare the phi variable with a copy at the right scope.
// We cannot safely declare a temporary here since we might be inside a continue block.
if (!var.allocate_temporary_copy)
{
var.allocate_temporary_copy = true;
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
Deal with phi copies which happen inside continue blocks.
2019-01-07 13:19:27 +00:00
}
statement("_", phi.function_variable, "_copy", " = ", to_name(phi.function_variable), ";");
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
temporary_phi_variables.insert(phi.function_variable);
}
Fix case when Phi variable is a loop variable. Need to flush variable to static expression rather than a variable.
2017-09-25 08:15:17 +00:00
// This might be called in continue block, so make sure we
Fix typo.
2017-09-25 08:16:45 +00:00
// use this to emit ESSL 1.0 compliant increments/decrements.
Fix case when Phi variable is a loop variable. Need to flush variable to static expression rather than a variable.
2017-09-25 08:15:17 +00:00
auto lhs = to_expression(phi.function_variable);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
string rhs;
if (temporary_phi_variables.count(phi.local_variable))
rhs = join("_", phi.local_variable, "_copy");
else
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
rhs = to_pointer_expression(phi.local_variable);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
Do not use RMW rewrite for matrices. Does not work on MSL.
2018-05-04 08:35:32 +00:00
if (!optimize_read_modify_write(get<SPIRType>(var.basetype), lhs, rhs))
Fix case when Phi variable is a loop variable. Need to flush variable to static expression rather than a variable.
2017-09-25 08:15:17 +00:00
statement(lhs, " = ", rhs, ";");
}
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
register_write(phi.function_variable);
Fix case when Phi variable is a loop variable. Need to flush variable to static expression rather than a variable.
2017-09-25 08:15:17 +00:00
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
void CompilerGLSL::branch_to_continue(BlockID from, BlockID to)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
auto &to_block = get<SPIRBlock>(to);
Update tests for latest SPIRV-Tools and glslang.
2018-03-12 13:58:40 +00:00
if (from == to)
return;
assert(is_continue(to));
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
if (to_block.complex_continue)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
// Just emit the whole block chain as is.
auto usage_counts = expression_usage_counts;
emit_block_chain(to_block);
Do not eagerly invalidate all active variables on a branch. This is not necessary, as we must emit an invalidating store before we potentially consume an invalid expression. In fact, we're a bit conservative here in this case for example: int tmp = variable; if (...) { variable = 10; } else { // Consuming tmp here is fine, but it was // invalidated while emitting other branch. // Technically, we need to study if there is an invalidating store // in the CFG between the loading block and this block, and the other // branch will not be a part of that analysis. int tmp2 = tmp * tmp; } Fixing this case means complex CFG traversal *everywhere*, and it feels like overkill. Fixing this exposed a bug with access chains, so fix a bug where expression dependencies were not inherited properly in access chains. Access chains are now considered forwarded if there is at least one dependency which is also forwarded.
2019-07-24 09:10:18 +00:00
// Expression usage counts are moot after returning from the continue block.
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
expression_usage_counts = usage_counts;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
else
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
auto &from_block = get<SPIRBlock>(from);
bool outside_control_flow = false;
uint32_t loop_dominator = 0;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
// FIXME: Refactor this to not use the old loop_dominator tracking.
if (from_block.merge_block)
{
// If we are a loop header, we don't set the loop dominator,
// so just use "self" here.
loop_dominator = from;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
else if (from_block.loop_dominator != BlockID(SPIRBlock::NoDominator))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
loop_dominator = from_block.loop_dominator;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
if (loop_dominator != 0)
{
Move branchless analysis to CFG. Traverse backwards instead, far more robust. Should elide basically all redundant continue; statements now.
2019-08-26 13:36:23 +00:00
auto &cfg = get_cfg_for_current_function();
Fix case where loop header branches into continue block.
2018-02-01 08:59:17 +00:00
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
// For non-complex continue blocks, we implicitly branch to the continue block
// by having the continue block be part of the loop header in for (; ; continue-block).
Move branchless analysis to CFG. Traverse backwards instead, far more robust. Should elide basically all redundant continue; statements now.
2019-08-26 13:36:23 +00:00
outside_control_flow = cfg.node_terminates_control_flow_in_sub_graph(loop_dominator, from);
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
}
Fix case where loop header branches into continue block.
2018-02-01 08:59:17 +00:00
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
// Some simplification for for-loops. We always end up with a useless continue;
// statement since we branch to a loop block.
Elide branches to continue block when continue block is also a merge.
2019-08-26 12:21:35 +00:00
// Walk the CFG, if we unconditionally execute the block calling continue assuming we're in the loop block,
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
// we can avoid writing out an explicit continue statement.
// Similar optimization to return statements if we know we're outside flow control.
if (!outside_control_flow)
statement("continue;");
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
void CompilerGLSL::branch(BlockID from, BlockID to)
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
{
flush_phi(from, to);
Handle control-dependent temporaries. Derivatives, subgroup and implicit-lod instructions all need to happen in the block they were created.
2018-03-12 16:34:54 +00:00
flush_control_dependent_expressions(from);
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
Elide branches to continue block when continue block is also a merge.
2019-08-26 12:21:35 +00:00
bool to_is_continue = is_continue(to);
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
// This is only a continue if we branch to our loop dominator.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if ((ir.block_meta[to] & ParsedIR::BLOCK_META_LOOP_HEADER_BIT) != 0 && get<SPIRBlock>(from).loop_dominator == to)
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
{
// This can happen if we had a complex continue block which was emitted.
// Once the continue block tries to branch to the loop header, just emit continue;
// and end the chain here.
statement("continue;");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Handle case where block is loop header, continue AND break block.
2020-10-27 11:29:08 +00:00
else if (from != to && is_break(to))
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
{
Handle case where block is loop header, continue AND break block.
2020-10-27 11:29:08 +00:00
// We cannot break to ourselves, so check explicitly for from != to.
// This case can trigger if a loop header is all three of these things:
// - Continue block
// - Loop header
// - Break merge target all at once ...
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
// Very dirty workaround.
Handle multiple breaks out of switches. Use a switch stack instead.
2022-07-22 13:29:48 +00:00
// Switch constructs are able to break, but they cannot break out of a loop at the same time,
// yet SPIR-V allows it.
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
// Only sensible solution is to make a ladder variable, which we declare at the top of the switch block,
// write to the ladder here, and defer the break.
// The loop we're breaking out of must dominate the switch block, or there is no ladder breaking case.
Handle multiple breaks out of switches. Use a switch stack instead.
2022-07-22 13:29:48 +00:00
if (is_loop_break(to))
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
{
Handle multiple breaks out of switches. Use a switch stack instead.
2022-07-22 13:29:48 +00:00
for (size_t n = current_emitting_switch_stack.size(); n; n--)
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
{
Handle multiple breaks out of switches. Use a switch stack instead.
2022-07-22 13:29:48 +00:00
auto *current_emitting_switch = current_emitting_switch_stack[n - 1];
if (current_emitting_switch &&
current_emitting_switch->loop_dominator != BlockID(SPIRBlock::NoDominator) &&
get<SPIRBlock>(current_emitting_switch->loop_dominator).merge_block == to)
{
if (!current_emitting_switch->need_ladder_break)
{
force_recompile();
current_emitting_switch->need_ladder_break = true;
}
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
Handle multiple breaks out of switches. Use a switch stack instead.
2022-07-22 13:29:48 +00:00
statement("_", current_emitting_switch->self, "_ladder_break = true;");
}
else
break;
}
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("break;");
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
}
Elide branches to continue block when continue block is also a merge.
2019-08-26 12:21:35 +00:00
else if (to_is_continue || from == to)
Update tests for latest SPIRV-Tools and glslang.
2018-03-12 13:58:40 +00:00
{
// For from == to case can happen for a do-while loop which branches into itself.
// We don't mark these cases as continue blocks, but the only possible way to branch into
// ourselves is through means of continue blocks.
Elide branches to continue block when continue block is also a merge.
2019-08-26 12:21:35 +00:00
// If we are merging to a continue block, there is no need to emit the block chain for continue here.
// We can branch to the continue block after we merge execution.
// Here we make use of structured control flow rules from spec:
// 2.11: - the merge block declared by a header block cannot be a merge block declared by any other header block
// - each header block must strictly dominate its merge block, unless the merge block is unreachable in the CFG
// If we are branching to a merge block, we must be inside a construct which dominates the merge block.
auto &block_meta = ir.block_meta[to];
bool branching_to_merge =
(block_meta & (ParsedIR::BLOCK_META_SELECTION_MERGE_BIT | ParsedIR::BLOCK_META_MULTISELECT_MERGE_BIT |
ParsedIR::BLOCK_META_LOOP_MERGE_BIT)) != 0;
if (!to_is_continue || !branching_to_merge)
branch_to_continue(from, to);
Update tests for latest SPIRV-Tools and glslang.
2018-03-12 13:58:40 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else if (!is_conditional(to))
emit_block_chain(get<SPIRBlock>(to));
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
// It is important that we check for break before continue.
// A block might serve two purposes, a break block for the inner scope, and
// a continue block in the outer scope.
// Inner scope always takes precedence.
Initial commit.
2016-03-02 17:09:16 +00:00
}
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
void CompilerGLSL::branch(BlockID from, uint32_t cond, BlockID true_block, BlockID false_block)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Missed case where DoWhile continue block deals with Phi.
2019-07-25 10:30:50 +00:00
auto &from_block = get<SPIRBlock>(from);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
BlockID merge_block = from_block.merge == SPIRBlock::MergeSelection ? from_block.next_block : BlockID(0);
Missed case where DoWhile continue block deals with Phi.
2019-07-25 10:30:50 +00:00
Clean up conditional branch codegen. Should only need to look at whether or not we're branching to our own merge target. Any other branch needs to emit code in some way.
2020-09-17 10:12:37 +00:00
// If we branch directly to our selection merge target, we don't need a code path.
bool true_block_needs_code = true_block != merge_block || flush_phi_required(from, true_block);
bool false_block_needs_code = false_block != merge_block || flush_phi_required(from, false_block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Clean up conditional branch codegen. Should only need to look at whether or not we're branching to our own merge target. Any other branch needs to emit code in some way.
2020-09-17 10:12:37 +00:00
if (!true_block_needs_code && !false_block_needs_code)
return;
Missed case where DoWhile continue block deals with Phi.
2019-07-25 10:30:50 +00:00
Ensure loop control flow hints only appear above loops.
2021-06-03 10:19:10 +00:00
// We might have a loop merge here. Only consider selection flattening constructs.
// Loop hints are handled explicitly elsewhere.
if (from_block.hint == SPIRBlock::HintFlatten || from_block.hint == SPIRBlock::HintDontFlatten)
emit_block_hints(from_block);
Deal with case where a selection construct conditionally merges/breaks.
2020-09-17 10:02:43 +00:00
Clean up conditional branch codegen. Should only need to look at whether or not we're branching to our own merge target. Any other branch needs to emit code in some way.
2020-09-17 10:12:37 +00:00
if (true_block_needs_code)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
statement("if (", to_expression(cond), ")");
begin_scope();
branch(from, true_block);
end_scope();
Clean up conditional branch codegen. Should only need to look at whether or not we're branching to our own merge target. Any other branch needs to emit code in some way.
2020-09-17 10:12:37 +00:00
if (false_block_needs_code)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
statement("else");
begin_scope();
branch(from, false_block);
end_scope();
}
}
Clean up conditional branch codegen. Should only need to look at whether or not we're branching to our own merge target. Any other branch needs to emit code in some way.
2020-09-17 10:12:37 +00:00
else if (false_block_needs_code)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
// Only need false path, use negative conditional.
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
statement("if (!", to_enclosed_expression(cond), ")");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
begin_scope();
branch(from, false_block);
end_scope();
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
// FIXME: This currently cannot handle complex continue blocks
// as in do-while.
// This should be seen as a "trivial" continue block.
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
string CompilerGLSL::emit_continue_block(uint32_t continue_block, bool follow_true_block, bool follow_false_block)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
auto *block = &get<SPIRBlock>(continue_block);
// While emitting the continue block, declare_temporary will check this
// if we have to emit temporaries.
current_continue_block = block;
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<string> statements;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Capture all statements into our list.
auto *old = redirect_statement;
redirect_statement = &statements;
// Stamp out all blocks one after each other.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
while ((ir.block_meta[block->self] & ParsedIR::BLOCK_META_LOOP_HEADER_BIT) == 0)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
// Write out all instructions we have in this block.
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
emit_block_instructions(*block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// For plain branchless for/while continue blocks.
if (block->next_block)
{
flush_phi(continue_block, block->next_block);
block = &get<SPIRBlock>(block->next_block);
}
// For do while blocks. The last block will be a select block.
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
else if (block->true_block && follow_true_block)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
flush_phi(continue_block, block->true_block);
block = &get<SPIRBlock>(block->true_block);
}
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
else if (block->false_block && follow_false_block)
{
flush_phi(continue_block, block->false_block);
block = &get<SPIRBlock>(block->false_block);
}
else
{
SPIRV_CROSS_THROW("Invalid continue block detected!");
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
// Restore old pointer.
redirect_statement = old;
// Somewhat ugly, strip off the last ';' since we use ',' instead.
// Ideally, we should select this behavior in statement().
for (auto &s : statements)
{
if (!s.empty() && s.back() == ';')
Fix compilation on some old C++11 standard libraries.
2016-10-05 17:01:31 +00:00
s.erase(s.size() - 1, 1);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
current_continue_block = nullptr;
return merge(statements);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Deal with loop variable initializers for non-for loops.
2018-08-06 10:52:22 +00:00
void CompilerGLSL::emit_while_loop_initializers(const SPIRBlock &block)
{
// While loops do not take initializers, so declare all of them outside.
for (auto &loop_var : block.loop_variables)
{
auto &var = get<SPIRVariable>(loop_var);
statement(variable_decl(var), ";");
}
}
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
string CompilerGLSL::emit_for_loop_initializers(const SPIRBlock &block)
{
if (block.loop_variables.empty())
return "";
Do not use inline for-loop initializers with different types.
2018-01-16 09:27:58 +00:00
bool same_types = for_loop_initializers_are_same_type(block);
// We can only declare for loop initializers if all variables are of same type.
// If we cannot do this, declare individual variables before the loop header.
Check if a loop variable candidate is actually used. Phi nodes used in continue blocks are not always loop variables. Fix by checking if path from dominator to loop header has some variable use.
2018-01-23 19:27:43 +00:00
// We might have a loop variable candidate which was not assigned to for some reason.
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
uint32_t missing_initializers = 0;
Check if a loop variable candidate is actually used. Phi nodes used in continue blocks are not always loop variables. Fix by checking if path from dominator to loop header has some variable use.
2018-01-23 19:27:43 +00:00
for (auto &variable : block.loop_variables)
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
{
uint32_t expr = get<SPIRVariable>(variable).static_expression;
// Sometimes loop variables are initialized with OpUndef, but we can just declare
// a plain variable without initializer in this case.
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (expr == 0 || ir.ids[expr].get_type() == TypeUndef)
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
missing_initializers++;
}
Check if a loop variable candidate is actually used. Phi nodes used in continue blocks are not always loop variables. Fix by checking if path from dominator to loop header has some variable use.
2018-01-23 19:27:43 +00:00
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
if (block.loop_variables.size() == 1 && missing_initializers == 0)
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
{
return variable_decl(get<SPIRVariable>(block.loop_variables.front()));
}
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
else if (!same_types || missing_initializers == uint32_t(block.loop_variables.size()))
Do not use inline for-loop initializers with different types.
2018-01-16 09:27:58 +00:00
{
for (auto &loop_var : block.loop_variables)
statement(variable_decl(get<SPIRVariable>(loop_var)), ";");
return "";
}
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
else
{
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
// We have a mix of loop variables, either ones with a clear initializer, or ones without.
// Separate the two streams.
string expr;
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
for (auto &loop_var : block.loop_variables)
{
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
uint32_t static_expr = get<SPIRVariable>(loop_var).static_expression;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (static_expr == 0 || ir.ids[static_expr].get_type() == TypeUndef)
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
{
statement(variable_decl(get<SPIRVariable>(loop_var)), ";");
}
else
{
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
auto &var = get<SPIRVariable>(loop_var);
auto &type = get_variable_data_type(var);
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
if (expr.empty())
{
// For loop initializers are of the form <type id = value, id = value, id = value, etc ...
expr = join(to_qualifiers_glsl(var.self), type_to_glsl(type), " ");
}
else
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
{
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
expr += ", ";
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
// In MSL, being based on C++, the asterisk marking a pointer
// binds to the identifier, not the type.
if (type.pointer)
expr += "* ";
}
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
expr += join(to_name(loop_var), " = ", to_pointer_expression(var.static_expression));
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
}
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
}
return expr;
}
}
Do not use inline for-loop initializers with different types.
2018-01-16 09:27:58 +00:00
bool CompilerGLSL::for_loop_initializers_are_same_type(const SPIRBlock &block)
{
if (block.loop_variables.size() <= 1)
return true;
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
uint32_t expected = 0;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
Bitset expected_flags;
Do not use inline for-loop initializers with different types.
2018-01-16 09:27:58 +00:00
for (auto &var : block.loop_variables)
{
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
// Don't care about uninitialized variables as they will not be part of the initializers.
uint32_t expr = get<SPIRVariable>(var).static_expression;
Hoist out parsing module from spirv_cross::Compiler. This is a large refactor which splits out the SPIR-V parser from Compiler and moves it into its more appropriately named Parser module. The Parser is responsible for building a ParsedIR structure which is then consumed by one or more compilers. Compiler can take a ParsedIR by value or move reference. This should allow for optimal case for both multiple compilations and single compilation scenarios.
2018-10-05 09:30:57 +00:00
if (expr == 0 || ir.ids[expr].get_type() == TypeUndef)
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
continue;
if (expected == 0)
{
expected = get<SPIRVariable>(var).basetype;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
expected_flags = get_decoration_bitset(var);
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
}
else if (expected != get<SPIRVariable>(var).basetype)
Do not use inline for-loop initializers with different types.
2018-01-16 09:27:58 +00:00
return false;
// Precision flags and things like that must also match.
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (expected_flags != get_decoration_bitset(var))
Do not use inline for-loop initializers with different types.
2018-01-16 09:27:58 +00:00
return false;
}
return true;
}
Skip line directives when emitting loop condition blocks. Avoids problem where enabling line directives breaks loop optimizations since it thinks there are legitimate statements in the block.
2023-06-12 10:33:58 +00:00
void CompilerGLSL::emit_block_instructions_with_masked_debug(SPIRBlock &block)
{
// Have to block debug instructions such as OpLine here, since it will be treated as a statement otherwise,
// which breaks loop optimizations.
// Any line directive would be declared outside the loop body, which would just be confusing either way.
bool old_block_debug_directives = block_debug_directives;
block_debug_directives = true;
emit_block_instructions(block);
block_debug_directives = old_block_debug_directives;
}
Initial commit.
2016-03-02 17:09:16 +00:00
bool CompilerGLSL::attempt_emit_loop_header(SPIRBlock &block, SPIRBlock::Method method)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
SPIRBlock::ContinueBlockType continue_type = continue_block_type(get<SPIRBlock>(block.continue_block));
Emit complex continue blocks "properly".
2018-03-08 16:51:55 +00:00
if (method == SPIRBlock::MergeToSelectForLoop || method == SPIRBlock::MergeToSelectContinueForLoop)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
uint32_t current_count = statement_count;
// If we're trying to create a true for loop,
// we need to make sure that all opcodes before branch statement do not actually emit any code.
// We can then take the condition expression and create a for (; cond ; ) { body; } structure instead.
Skip line directives when emitting loop condition blocks. Avoids problem where enabling line directives breaks loop optimizations since it thinks there are legitimate statements in the block.
2023-06-12 10:33:58 +00:00
emit_block_instructions_with_masked_debug(block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
bool condition_is_temporary = forced_temporaries.find(block.condition) == end(forced_temporaries);
Block loop optimization if Phi is used. Somehow this hasn't been caught until now. Impressive. We'll have to emit side effects in condition block to make this work, which breaks loop conditionals.
2024-03-18 11:09:13 +00:00
bool flushes_phi = flush_phi_required(block.self, block.true_block) ||
flush_phi_required(block.self, block.false_block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// This can work! We only did trivial things which could be forwarded in block body!
Block loop optimization if Phi is used. Somehow this hasn't been caught until now. Impressive. We'll have to emit side effects in condition block to make this work, which breaks loop conditionals.
2024-03-18 11:09:13 +00:00
if (!flushes_phi && current_count == statement_count && condition_is_temporary)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
switch (continue_type)
{
case SPIRBlock::ForLoop:
Fix execution order for for-loop emission. In some cases, the compiler decided to emit continue block first, which invalidated the expressions used by the condition. Parameters to functions can be evaluated in any order which caused "random" behavior.
2017-02-04 09:07:20 +00:00
{
Lift variable accesses in continue blocks out to loop header.
2017-12-05 16:40:23 +00:00
// This block may be a dominating block, so make sure we flush undeclared variables before building the for loop header.
flush_undeclared_variables(block);
Fix execution order for for-loop emission. In some cases, the compiler decided to emit continue block first, which invalidated the expressions used by the condition. Parameters to functions can be evaluated in any order which caused "random" behavior.
2017-02-04 09:07:20 +00:00
// Important that we do this in this order because
// emitting the continue block can invalidate the condition expression.
auto initializer = emit_for_loop_initializers(block);
auto condition = to_expression(block.condition);
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
// Condition might have to be inverted.
if (execution_is_noop(get<SPIRBlock>(block.true_block), get<SPIRBlock>(block.merge_block)))
condition = join("!", enclose_expression(condition));
Deal with loop variable initializers for non-for loops.
2018-08-06 10:52:22 +00:00
emit_block_hints(block);
Emit complex continue blocks "properly".
2018-03-08 16:51:55 +00:00
if (method != SPIRBlock::MergeToSelectContinueForLoop)
{
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
auto continue_block = emit_continue_block(block.continue_block, false, false);
Emit complex continue blocks "properly".
2018-03-08 16:51:55 +00:00
statement("for (", initializer, "; ", condition, "; ", continue_block, ")");
}
else
statement("for (", initializer, "; ", condition, "; )");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Fix execution order for for-loop emission. In some cases, the compiler decided to emit continue block first, which invalidated the expressions used by the condition. Parameters to functions can be evaluated in any order which caused "random" behavior.
2017-02-04 09:07:20 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRBlock::WhileLoop:
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
{
Lift variable accesses in continue blocks out to loop header.
2017-12-05 16:40:23 +00:00
// This block may be a dominating block, so make sure we flush undeclared variables before building the while loop header.
flush_undeclared_variables(block);
Deal with loop variable initializers for non-for loops.
2018-08-06 10:52:22 +00:00
emit_while_loop_initializers(block);
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +00:00
emit_block_hints(block);
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
auto condition = to_expression(block.condition);
// Condition might have to be inverted.
if (execution_is_noop(get<SPIRBlock>(block.true_block), get<SPIRBlock>(block.merge_block)))
condition = join("!", enclose_expression(condition));
statement("while (", condition, ")");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
Fall back to complex loop if non-trivial continue block is found. There is a case where we can deduce a for/while loop, but the continue block is actually very painful to deal with, so handle that case as well. Removes an exceptional case.
2019-07-08 09:48:44 +00:00
block.disable_block_optimization = true;
force_recompile();
begin_scope(); // We'll see an end_scope() later.
return false;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
begin_scope();
return true;
}
else
{
block.disable_block_optimization = true;
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
begin_scope(); // We'll see an end_scope() later.
return false;
}
}
else if (method == SPIRBlock::MergeToDirectForLoop)
{
auto &child = get<SPIRBlock>(block.next_block);
Handle more corner cases with the CFG traversal.
2016-11-18 15:45:11 +00:00
// This block may be a dominating block, so make sure we flush undeclared variables before building the for loop header.
flush_undeclared_variables(child);
uint32_t current_count = statement_count;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// If we're trying to create a true for loop,
// we need to make sure that all opcodes before branch statement do not actually emit any code.
// We can then take the condition expression and create a for (; cond ; ) { body; } structure instead.
Skip line directives when emitting loop condition blocks. Avoids problem where enabling line directives breaks loop optimizations since it thinks there are legitimate statements in the block.
2023-06-12 10:33:58 +00:00
emit_block_instructions_with_masked_debug(child);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
bool condition_is_temporary = forced_temporaries.find(child.condition) == end(forced_temporaries);
Block loop optimization if Phi is used. Somehow this hasn't been caught until now. Impressive. We'll have to emit side effects in condition block to make this work, which breaks loop conditionals.
2024-03-18 11:09:13 +00:00
bool flushes_phi = flush_phi_required(child.self, child.true_block) ||
flush_phi_required(child.self, child.false_block);
if (!flushes_phi && current_count == statement_count && condition_is_temporary)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
uint32_t target_block = child.true_block;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
switch (continue_type)
{
case SPIRBlock::ForLoop:
Fix execution order for for-loop emission. In some cases, the compiler decided to emit continue block first, which invalidated the expressions used by the condition. Parameters to functions can be evaluated in any order which caused "random" behavior.
2017-02-04 09:07:20 +00:00
{
// Important that we do this in this order because
// emitting the continue block can invalidate the condition expression.
auto initializer = emit_for_loop_initializers(block);
auto condition = to_expression(child.condition);
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
// Condition might have to be inverted.
if (execution_is_noop(get<SPIRBlock>(child.true_block), get<SPIRBlock>(block.merge_block)))
{
condition = join("!", enclose_expression(condition));
target_block = child.false_block;
}
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
auto continue_block = emit_continue_block(block.continue_block, false, false);
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +00:00
emit_block_hints(block);
Fix execution order for for-loop emission. In some cases, the compiler decided to emit continue block first, which invalidated the expressions used by the condition. Parameters to functions can be evaluated in any order which caused "random" behavior.
2017-02-04 09:07:20 +00:00
statement("for (", initializer, "; ", condition, "; ", continue_block, ")");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Fix execution order for for-loop emission. In some cases, the compiler decided to emit continue block first, which invalidated the expressions used by the condition. Parameters to functions can be evaluated in any order which caused "random" behavior.
2017-02-04 09:07:20 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRBlock::WhileLoop:
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
{
Deal with loop variable initializers for non-for loops.
2018-08-06 10:52:22 +00:00
emit_while_loop_initializers(block);
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +00:00
emit_block_hints(block);
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
auto condition = to_expression(child.condition);
// Condition might have to be inverted.
if (execution_is_noop(get<SPIRBlock>(child.true_block), get<SPIRBlock>(block.merge_block)))
{
condition = join("!", enclose_expression(condition));
target_block = child.false_block;
}
statement("while (", condition, ")");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
Fall back to complex loop if non-trivial continue block is found. There is a case where we can deduce a for/while loop, but the continue block is actually very painful to deal with, so handle that case as well. Removes an exceptional case.
2019-07-08 09:48:44 +00:00
block.disable_block_optimization = true;
force_recompile();
begin_scope(); // We'll see an end_scope() later.
return false;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
begin_scope();
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
branch(child.self, target_block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
return true;
}
else
{
block.disable_block_optimization = true;
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
begin_scope(); // We'll see an end_scope() later.
return false;
}
}
else
return false;
Initial commit.
2016-03-02 17:09:16 +00:00
}
Start adding CFG analysis. Not complete yet, but partly working ...
2016-11-11 17:04:14 +00:00
void CompilerGLSL::flush_undeclared_variables(SPIRBlock &block)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Start adding CFG analysis. Not complete yet, but partly working ...
2016-11-11 17:04:14 +00:00
for (auto &v : block.dominated_variables)
Deal with phi copies which happen inside continue blocks.
2019-01-07 13:19:27 +00:00
flush_variable_declaration(v);
Initial commit.
2016-03-02 17:09:16 +00:00
}
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
void CompilerGLSL::emit_hoisted_temporaries(SmallVector<pair<TypeID, ID>> &temporaries)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// If we need to force temporaries for certain IDs due to continue blocks, do it before starting loop header.
Need to sort declared temporaries to ensure stable output.
2018-01-29 09:22:18 +00:00
// Need to sort these to ensure that reference output is stable.
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
sort(begin(temporaries), end(temporaries),
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
[](const pair<TypeID, ID> &a, const pair<TypeID, ID> &b) { return a.second < b.second; });
Need to sort declared temporaries to ensure stable output.
2018-01-29 09:22:18 +00:00
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
for (auto &tmp : temporaries)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Do not emit hoisted access chain temporaries unless backend supports it. This can happen for access chains into buffer objects which were marked as potentially hoisted, but it's benign in almost all cases.
2022-02-16 10:36:38 +00:00
auto &type = get<SPIRType>(tmp.first);
// There are some rare scenarios where we are asked to declare pointer types as hoisted temporaries.
// This should be ignored unless we're doing actual variable pointers and backend supports it.
// Access chains cannot normally be lowered to temporaries in GLSL and HLSL.
if (type.pointer && !backend.native_pointers)
continue;
Fix name aliasing for temporary variables.
2018-03-24 00:53:08 +00:00
add_local_variable_name(tmp.second);
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
auto &flags = get_decoration_bitset(tmp.second);
Add support for forcefully zero-initialized variables. Useful to better support certain platforms which require all variables to be initialized to something.
2020-03-26 10:21:23 +00:00
// Not all targets support pointer literals, so don't bother with that case.
string initializer;
if (options.force_zero_initialized_variables && type_can_zero_initialize(type))
initializer = join(" = ", to_zero_initialized_expression(tmp.first));
statement(flags_to_qualifiers_glsl(type, flags), variable_decl(type, to_name(tmp.second)), initializer, ";");
Fix case where hoisted temporaries were used before being declared.
2018-02-15 09:52:56 +00:00
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
hoisted_temporaries.insert(tmp.second);
forced_temporaries.insert(tmp.second);
Fix case where hoisted temporaries were used before being declared.
2018-02-15 09:52:56 +00:00
// The temporary might be read from before it's assigned, set up the expression now.
set<SPIRExpression>(tmp.second, to_name(tmp.second), tmp.first, true);
GLSL: Handle more proper semantics for RelaxedPrecision. GLSL and RelaxedPrecision are quite different in what they affect. RelaxedPrecision affects operations, while this is merely implied in GLSL based on inputs. This leads to situations where we have to promote mediump inputs to highp, and the simplest approach is to force highp temporaries for inputs which are consumed in a highp context. For completeness, we also demote RelaxedPrecision inputs to mediump variables. PHI is handled by copying the PHI into a temporary. We have to be very careful with hoisted temporaries, since the child temporary will not be analyzed up-front. We inherit the hoisted-ness state and emit the hoisted child temporary as necessary. When faking the temporaries with OpCopyObject, we make sure to block any variable hoisting. Hoisting children of PHI variables is fine, since PHIs are not hoisted with the same framework as other temporaries.
2022-04-29 11:49:02 +00:00
// If we have hoisted temporaries in multi-precision contexts, emit that here too ...
// We will not be able to analyze hoisted-ness for dependent temporaries that we hallucinate here.
auto mirrored_precision_itr = temporary_to_mirror_precision_alias.find(tmp.second);
if (mirrored_precision_itr != temporary_to_mirror_precision_alias.end())
{
uint32_t mirror_id = mirrored_precision_itr->second;
auto &mirror_flags = get_decoration_bitset(mirror_id);
statement(flags_to_qualifiers_glsl(type, mirror_flags),
variable_decl(type, to_name(mirror_id)),
initializer, ";");
// The temporary might be read from before it's assigned, set up the expression now.
set<SPIRExpression>(mirror_id, to_name(mirror_id), tmp.first, true);
hoisted_temporaries.insert(mirror_id);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
}
void CompilerGLSL::emit_block_chain(SPIRBlock &block)
{
bool select_branch_to_true_block = false;
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
bool select_branch_to_false_block = false;
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
bool skip_direct_branch = false;
We emit loop header variables even for while and dowhile. Make the name clearer.
2019-03-06 11:30:11 +00:00
bool emitted_loop_header_variables = false;
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
bool force_complex_continue_block = false;
Implement context-sensitive expression read tracking. When inside a loop, treat any read of outer expressions to happen multiple times, forcing a temporary of said outer expressions. This avoids the problem where we can end up relying on loop-invariant code motion to happen in the compiler when converting optimized shaders.
2020-06-29 10:20:35 +00:00
ValueSaver<uint32_t> loop_level_saver(current_loop_level);
if (block.merge == SPIRBlock::MergeLoop)
add_loop_level();
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
GLSL: Fix bug with mixed precision on PHI variables.
2023-06-07 12:49:42 +00:00
// If we're emitting PHI variables with precision aliases, we have to emit them as hoisted temporaries.
for (auto var_id : block.dominated_variables)
{
auto &var = get<SPIRVariable>(var_id);
if (var.phi_variable)
{
auto mirrored_precision_itr = temporary_to_mirror_precision_alias.find(var_id);
if (mirrored_precision_itr != temporary_to_mirror_precision_alias.end() &&
find_if(block.declare_temporary.begin(), block.declare_temporary.end(),
[mirrored_precision_itr](const std::pair<TypeID, VariableID> &p) {
return p.second == mirrored_precision_itr->second;
}) == block.declare_temporary.end())
{
block.declare_temporary.push_back({ var.basetype, mirrored_precision_itr->second });
}
}
}
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
emit_hoisted_temporaries(block.declare_temporary);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
SPIRBlock::ContinueBlockType continue_type = SPIRBlock::ContinueNone;
if (block.continue_block)
Mark loop headers as complex as early as possible. We had a case where loops were marked complex in a cascading fashion where each loop iteration would discover one new complex loop. This was a problem with three nested loops.
2019-11-26 10:01:39 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
continue_type = continue_block_type(get<SPIRBlock>(block.continue_block));
Mark loop headers as complex as early as possible. We had a case where loops were marked complex in a cascading fashion where each loop iteration would discover one new complex loop. This was a problem with three nested loops.
2019-11-26 10:01:39 +00:00
// If we know we cannot emit a loop, mark the block early as a complex loop so we don't force unnecessary recompiles.
if (continue_type == SPIRBlock::ComplexLoop)
block.complex_continue = true;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Add directed test for for-loop-init.
2016-12-16 11:43:12 +00:00
// If we have loop variables, stop masking out access to the variable now.
Fix declaration of loop variables with a Phi helper copy. Certain Phi variables need to maintain a temporary copy, but we forgot to declare them when the master variable is a loop variable itself.
2019-06-25 08:45:15 +00:00
for (auto var_id : block.loop_variables)
{
auto &var = get<SPIRVariable>(var_id);
var.loop_variable_enable = true;
// We're not going to declare the variable directly, so emit a copy here.
emit_variable_temporary_copies(var);
}
Add directed test for for-loop-init.
2016-12-16 11:43:12 +00:00
Deal with case where a block is somehow emitted in a duplicated fashion. We seen to have to deal with a case where a block is used multiple times without any "proper" structured control flow, so we risk losing deferred declaration state.
2019-06-05 10:35:30 +00:00
// Remember deferred declaration state. We will restore it before returning.
SmallVector<bool, 64> rearm_dominated_variables(block.dominated_variables.size());
for (size_t i = 0; i < block.dominated_variables.size(); i++)
{
uint32_t var_id = block.dominated_variables[i];
auto &var = get<SPIRVariable>(var_id);
rearm_dominated_variables[i] = var.deferred_declaration;
}
Emit complex continue blocks "properly".
2018-03-08 16:51:55 +00:00
// This is the method often used by spirv-opt to implement loops.
// The loop header goes straight into the continue block.
// However, don't attempt this on ESSL 1.0, because if a loop variable is used in a continue block,
// it *MUST* be used in the continue block. This loop method will not work.
if (!is_legacy_es() && block_is_loop_candidate(block, SPIRBlock::MergeToSelectContinueForLoop))
{
flush_undeclared_variables(block);
if (attempt_emit_loop_header(block, SPIRBlock::MergeToSelectContinueForLoop))
{
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
if (execution_is_noop(get<SPIRBlock>(block.true_block), get<SPIRBlock>(block.merge_block)))
select_branch_to_false_block = true;
else
select_branch_to_true_block = true;
We emit loop header variables even for while and dowhile. Make the name clearer.
2019-03-06 11:30:11 +00:00
emitted_loop_header_variables = true;
Emit complex continue blocks "properly".
2018-03-08 16:51:55 +00:00
force_complex_continue_block = true;
}
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// This is the older loop behavior in glslang which branches to loop body directly from the loop header.
Emit complex continue blocks "properly".
2018-03-08 16:51:55 +00:00
else if (block_is_loop_candidate(block, SPIRBlock::MergeToSelectForLoop))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Start adding CFG analysis. Not complete yet, but partly working ...
2016-11-11 17:04:14 +00:00
flush_undeclared_variables(block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (attempt_emit_loop_header(block, SPIRBlock::MergeToSelectForLoop))
{
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
// The body of while, is actually just the true (or false) block, so always branch there unconditionally.
if (execution_is_noop(get<SPIRBlock>(block.true_block), get<SPIRBlock>(block.merge_block)))
select_branch_to_false_block = true;
else
select_branch_to_true_block = true;
We emit loop header variables even for while and dowhile. Make the name clearer.
2019-03-06 11:30:11 +00:00
emitted_loop_header_variables = true;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
// This is the newer loop behavior in glslang which branches from Loop header directly to
// a new block, which in turn has a OpBranchSelection without a selection merge.
else if (block_is_loop_candidate(block, SPIRBlock::MergeToDirectForLoop))
{
Start adding CFG analysis. Not complete yet, but partly working ...
2016-11-11 17:04:14 +00:00
flush_undeclared_variables(block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (attempt_emit_loop_header(block, SPIRBlock::MergeToDirectForLoop))
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
skip_direct_branch = true;
We emit loop header variables even for while and dowhile. Make the name clearer.
2019-03-06 11:30:11 +00:00
emitted_loop_header_variables = true;
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else if (continue_type == SPIRBlock::DoWhileLoop)
{
Fix CFG::update_common_dominator. The algorithm was too conservative causing lots of unnecessary temporaries to be created.
2018-01-24 18:46:53 +00:00
flush_undeclared_variables(block);
Deal with loop variable initializers for non-for loops.
2018-08-06 10:52:22 +00:00
emit_while_loop_initializers(block);
We emit loop header variables even for while and dowhile. Make the name clearer.
2019-03-06 11:30:11 +00:00
emitted_loop_header_variables = true;
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
// We have some temporaries where the loop header is the dominator.
// We risk a case where we have code like:
// for (;;) { create-temporary; break; } consume-temporary;
// so force-declare temporaries here.
emit_hoisted_temporaries(block.potential_declare_temporary);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("do");
begin_scope();
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
emit_block_instructions(block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else if (block.merge == SPIRBlock::MergeLoop)
{
Start adding CFG analysis. Not complete yet, but partly working ...
2016-11-11 17:04:14 +00:00
flush_undeclared_variables(block);
Deal with loop variable initializers for non-for loops.
2018-08-06 10:52:22 +00:00
emit_while_loop_initializers(block);
We emit loop header variables even for while and dowhile. Make the name clearer.
2019-03-06 11:30:11 +00:00
emitted_loop_header_variables = true;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// We have a generic loop without any distinguishable pattern like for, while or do while.
get<SPIRBlock>(block.continue_block).complex_continue = true;
continue_type = SPIRBlock::ComplexLoop;
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
// We have some temporaries where the loop header is the dominator.
// We risk a case where we have code like:
// for (;;) { create-temporary; break; } consume-temporary;
// so force-declare temporaries here.
emit_hoisted_temporaries(block.potential_declare_temporary);
Ensure loop control flow hints only appear above loops.
2021-06-03 10:19:10 +00:00
emit_block_hints(block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("for (;;)");
begin_scope();
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
emit_block_instructions(block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
{
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
emit_block_instructions(block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
// If we didn't successfully emit a loop header and we had loop variable candidates, we have a problem
// as writes to said loop variables might have been masked out, we need a recompile.
We emit loop header variables even for while and dowhile. Make the name clearer.
2019-03-06 11:30:11 +00:00
if (!emitted_loop_header_variables && !block.loop_variables.empty())
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
{
Rework how loop iteration counts are validated. Introduces an idea of a recompilation making forward progress. There are some extreme edge cases where we need more than 3 loops, but only allow this in specific circumstances where we can reason about forward progress being made.
2022-01-17 13:12:01 +00:00
force_recompile_guarantee_forward_progress();
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
for (auto var : block.loop_variables)
get<SPIRVariable>(var).loop_variable = false;
block.loop_variables.clear();
}
Start adding CFG analysis. Not complete yet, but partly working ...
2016-11-11 17:04:14 +00:00
flush_undeclared_variables(block);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
bool emit_next_block = true;
// Handle end of block.
switch (block.terminator)
{
case SPIRBlock::Direct:
// True when emitting complex continue block.
if (block.loop_dominator == block.next_block)
{
branch(block.self, block.next_block);
emit_next_block = false;
}
// True if MergeToDirectForLoop succeeded.
else if (skip_direct_branch)
emit_next_block = false;
else if (is_continue(block.next_block) || is_break(block.next_block) || is_conditional(block.next_block))
{
branch(block.self, block.next_block);
emit_next_block = false;
}
break;
case SPIRBlock::Select:
Emit complex continue blocks "properly".
2018-03-08 16:51:55 +00:00
// True if MergeToSelectForLoop or MergeToSelectContinueForLoop succeeded.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (select_branch_to_true_block)
Emit complex continue blocks "properly".
2018-03-08 16:51:55 +00:00
{
if (force_complex_continue_block)
{
assert(block.true_block == block.continue_block);
// We're going to emit a continue block directly here, so make sure it's marked as complex.
auto &complex_continue = get<SPIRBlock>(block.continue_block).complex_continue;
bool old_complex = complex_continue;
complex_continue = true;
branch(block.self, block.true_block);
complex_continue = old_complex;
}
else
branch(block.self, block.true_block);
}
Deal with more for loop candidate cases. We can trivially deal with cases where the loop tests are simply inverted. We can also deal with cases where the condition block branches to the merge block via other noop blocks. This makes SPIR-V codegen easier when targeting SPIRV-Cross.
2019-03-06 10:24:43 +00:00
else if (select_branch_to_false_block)
{
if (force_complex_continue_block)
{
assert(block.false_block == block.continue_block);
// We're going to emit a continue block directly here, so make sure it's marked as complex.
auto &complex_continue = get<SPIRBlock>(block.continue_block).complex_continue;
bool old_complex = complex_continue;
complex_continue = true;
branch(block.self, block.false_block);
complex_continue = old_complex;
}
else
branch(block.self, block.false_block);
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
else
branch(block.self, block.condition, block.true_block, block.false_block);
break;
case SPIRBlock::MultiSelect:
{
auto &type = expression_type(block.condition);
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
bool unsigned_case = type.basetype == SPIRType::UInt || type.basetype == SPIRType::UShort ||
type.basetype == SPIRType::UByte || type.basetype == SPIRType::UInt64;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Move check for structured OpSwitch to CompilerGLSL. Can still parse correctly.
2019-03-20 09:42:38 +00:00
if (block.merge == SPIRBlock::MergeNone)
SPIRV_CROSS_THROW("Switch statement is not structured");
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
if (!backend.support_64bit_switch && (type.basetype == SPIRType::UInt64 || type.basetype == SPIRType::Int64))
Fix unsigned switch case selectors.
2018-11-26 09:35:39 +00:00
{
// SPIR-V spec suggests this is allowed, but we cannot support it in higher level languages.
SPIRV_CROSS_THROW("Cannot use 64-bit switch selectors.");
}
const char *label_suffix = "";
if (type.basetype == SPIRType::UInt && backend.uint32_t_literal_suffix)
label_suffix = "u";
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
else if (type.basetype == SPIRType::Int64 && backend.support_64bit_switch)
label_suffix = "l";
else if (type.basetype == SPIRType::UInt64 && backend.support_64bit_switch)
label_suffix = "ul";
Fix unsigned switch case selectors.
2018-11-26 09:35:39 +00:00
else if (type.basetype == SPIRType::UShort)
label_suffix = backend.uint16_t_literal_suffix;
else if (type.basetype == SPIRType::Short)
label_suffix = backend.int16_t_literal_suffix;
Handle multiple breaks out of switches. Use a switch stack instead.
2022-07-22 13:29:48 +00:00
current_emitting_switch_stack.push_back(&block);
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
if (block.need_ladder_break)
statement("bool _", block.self, "_ladder_break = false;");
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
// Find all unique case constructs.
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
unordered_map<uint32_t, SmallVector<uint64_t>> case_constructs;
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
SmallVector<uint32_t> block_declaration_order;
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
SmallVector<uint64_t> literals_to_merge;
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
// If a switch case branches to the default block for some reason, we can just remove that literal from consideration
// and let the default: block handle it.
// 2.11 in SPIR-V spec states that for fall-through cases, there is a very strict declaration order which we can take advantage of here.
// We only need to consider possible fallthrough if order[i] branches to order[i + 1].
Added block.cases_32bit and reworked the cases fix Now we added block.cases_32bit as requested and we only parse if the remaining ops are a multiple of 2. None of them are mutable because we return a reference of them depending of the op.condition width. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-12 13:17:38 +00:00
auto &cases = get_case_list(block);
for (auto &c : cases)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
if (c.block != block.next_block && c.block != block.default_block)
{
if (!case_constructs.count(c.block))
block_declaration_order.push_back(c.block);
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
case_constructs[c.block].push_back(c.value);
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
}
else if (c.block == block.next_block && block.default_block != block.next_block)
{
// We might have to flush phi inside specific case labels.
// If we can piggyback on default:, do so instead.
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
literals_to_merge.push_back(c.value);
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
}
}
// Empty literal array -> default.
if (block.default_block != block.next_block)
{
auto &default_block = get<SPIRBlock>(block.default_block);
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
// We need to slide in the default block somewhere in this chain
// if there are fall-through scenarios since the default is declared separately in OpSwitch.
// Only consider trivial fall-through cases here.
size_t num_blocks = block_declaration_order.size();
bool injected_block = false;
for (size_t i = 0; i < num_blocks; i++)
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
{
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
auto &case_block = get<SPIRBlock>(block_declaration_order[i]);
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
if (execution_is_direct_branch(case_block, default_block))
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
{
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
// Fallthrough to default block, we must inject the default block here.
block_declaration_order.insert(begin(block_declaration_order) + i + 1, block.default_block);
injected_block = true;
break;
}
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
else if (execution_is_direct_branch(default_block, case_block))
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
{
// Default case is falling through to another case label, we must inject the default block here.
block_declaration_order.insert(begin(block_declaration_order) + i, block.default_block);
injected_block = true;
break;
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
}
}
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
// Order does not matter.
if (!injected_block)
block_declaration_order.push_back(block.default_block);
GLSL: Implement switch on ESSL 1.0. Cannot use switch on legacy ESSL, fallback to plain branches.
2020-06-29 11:23:13 +00:00
else if (is_legacy_es())
SPIRV_CROSS_THROW("Default case label fallthrough to other case label is not supported in ESSL 1.0.");
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
case_constructs[block.default_block] = {};
}
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
size_t num_blocks = block_declaration_order.size();
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
const auto to_case_label = [](uint64_t literal, uint32_t width, bool is_unsigned_case) -> string
{
if (is_unsigned_case)
return convert_to_string(literal);
// For smaller cases, the literals are compiled as 32 bit wide
// literals so we don't need to care for all sizes specifically.
if (width <= 32)
{
return convert_to_string(int64_t(int32_t(literal)));
}
return convert_to_string(int64_t(literal));
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
};
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
const auto to_legacy_case_label = [&](uint32_t condition, const SmallVector<uint64_t> &labels,
Run format_all.sh.
2020-07-01 09:42:58 +00:00
const char *suffix) -> string {
GLSL: Implement switch on ESSL 1.0. Cannot use switch on legacy ESSL, fallback to plain branches.
2020-06-29 11:23:13 +00:00
string ret;
size_t count = labels.size();
for (size_t i = 0; i < count; i++)
{
if (i)
ret += " || ";
ret += join(count > 1 ? "(" : "", to_enclosed_expression(condition), " == ", labels[i], suffix,
count > 1 ? ")" : "");
}
return ret;
};
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
// We need to deal with a complex scenario for OpPhi. If we have case-fallthrough and Phi in the picture,
// we need to flush phi nodes outside the switch block in a branch,
// and skip any Phi handling inside the case label to make fall-through work as expected.
// This kind of code-gen is super awkward and it's a last resort. Normally we would want to handle this
// inside the case label if at all possible.
GLSL: Implement switch on ESSL 1.0. Cannot use switch on legacy ESSL, fallback to plain branches.
2020-06-29 11:23:13 +00:00
for (size_t i = 1; backend.support_case_fallthrough && i < num_blocks; i++)
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
{
if (flush_phi_required(block.self, block_declaration_order[i]) &&
flush_phi_required(block_declaration_order[i - 1], block_declaration_order[i]))
{
uint32_t target_block = block_declaration_order[i];
// Make sure we flush Phi, it might have been marked to be ignored earlier.
get<SPIRBlock>(target_block).ignore_phi_from_block = 0;
auto &literals = case_constructs[target_block];
if (literals.empty())
{
// Oh boy, gotta make a complete negative test instead! o.o
// Find all possible literals that would *not* make us enter the default block.
// If none of those literals match, we flush Phi ...
SmallVector<string> conditions;
for (size_t j = 0; j < num_blocks; j++)
{
auto &negative_literals = case_constructs[block_declaration_order[j]];
for (auto &case_label : negative_literals)
Run format_all.sh.
2019-06-21 14:02:22 +00:00
conditions.push_back(join(to_enclosed_expression(block.condition),
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
" != ", to_case_label(case_label, type.width, unsigned_case)));
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
}
statement("if (", merge(conditions, " && "), ")");
begin_scope();
flush_phi(block.self, target_block);
end_scope();
}
else
{
SmallVector<string> conditions;
conditions.reserve(literals.size());
for (auto &case_label : literals)
Run format_all.sh.
2019-06-21 14:02:22 +00:00
conditions.push_back(join(to_enclosed_expression(block.condition),
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
" == ", to_case_label(case_label, type.width, unsigned_case)));
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
statement("if (", merge(conditions, " || "), ")");
begin_scope();
flush_phi(block.self, target_block);
end_scope();
}
// Mark the block so that we don't flush Phi from header to case label.
get<SPIRBlock>(target_block).ignore_phi_from_block = block.self;
}
}
HLSL: Workaround FXC bugs with degenerate switch blocks. When we see a switch block which only contains one default block, emit a do {} while(false) statement instead, which is far more idiomatic and readable anyways.
2020-06-23 13:39:04 +00:00
// If there is only one default block, and no cases, this is a case where SPIRV-opt decided to emulate
// non-structured exits with the help of a switch block.
// This is buggy on FXC, so just emit the logical equivalent of a do { } while(false), which is more idiomatic.
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
bool block_like_switch = cases.empty();
HLSL: Workaround FXC bugs with degenerate switch blocks. When we see a switch block which only contains one default block, emit a do {} while(false) statement instead, which is far more idiomatic and readable anyways.
2020-06-23 13:39:04 +00:00
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
// If this is true, the switch is completely meaningless, and we should just avoid it.
bool collapsed_switch = block_like_switch && block.default_block == block.next_block;
if (!collapsed_switch)
GLSL: Use for-loop fallback instead of do/while for legacy ESSL. do/while loops are not guaranteed to be supported in ESSL 1.0 / OpenGLES 2.0 implementations.
2020-06-29 10:50:31 +00:00
{
GLSL: Convert switch blocks to if statements in legacy desktop versions
2024-09-08 12:46:00 +00:00
if (block_like_switch || is_legacy())
GLSL: Fix nested legacy switch workarounds.
2020-06-30 10:02:24 +00:00
{
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
// ESSL 1.0 is not guaranteed to support do/while.
if (is_legacy_es())
{
uint32_t counter = statement_count;
statement("for (int spvDummy", counter, " = 0; spvDummy", counter, " < 1; spvDummy", counter,
"++)");
}
else
statement("do");
GLSL: Fix nested legacy switch workarounds.
2020-06-30 10:02:24 +00:00
}
GLSL: Use for-loop fallback instead of do/while for legacy ESSL. do/while loops are not guaranteed to be supported in ESSL 1.0 / OpenGLES 2.0 implementations.
2020-06-29 10:50:31 +00:00
else
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
{
emit_block_hints(block);
statement("switch (", to_unpacked_expression(block.condition), ")");
}
begin_scope();
HLSL: Workaround FXC bugs with degenerate switch blocks. When we see a switch block which only contains one default block, emit a do {} while(false) statement instead, which is far more idiomatic and readable anyways.
2020-06-23 13:39:04 +00:00
}
Deal with OpPhi and case fallthrough. This is quite complex since we cannot flush Phi inside the case labels, we have to do it outside by emitting a lot of manual branches ourselves. This should be extremely rare, but we need to handle this case.
2019-06-21 09:16:51 +00:00
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
for (size_t i = 0; i < num_blocks; i++)
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
{
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
uint32_t target_block = block_declaration_order[i];
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
auto &literals = case_constructs[target_block];
if (literals.empty())
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
{
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
// Default case.
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
if (!block_like_switch)
GLSL: Implement switch on ESSL 1.0. Cannot use switch on legacy ESSL, fallback to plain branches.
2020-06-29 11:23:13 +00:00
{
GLSL: Convert switch blocks to if statements in legacy desktop versions
2024-09-08 12:46:00 +00:00
if (is_legacy())
GLSL: Implement switch on ESSL 1.0. Cannot use switch on legacy ESSL, fallback to plain branches.
2020-06-29 11:23:13 +00:00
statement("else");
else
statement("default:");
}
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
}
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
else
{
GLSL: Convert switch blocks to if statements in legacy desktop versions
2024-09-08 12:46:00 +00:00
if (is_legacy())
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
{
Run format_all.sh.
2020-07-01 09:42:58 +00:00
statement((i ? "else " : ""), "if (", to_legacy_case_label(block.condition, literals, label_suffix),
GLSL: Implement switch on ESSL 1.0. Cannot use switch on legacy ESSL, fallback to plain branches.
2020-06-29 11:23:13 +00:00
")");
}
else
{
for (auto &case_literal : literals)
{
// The case label value must be sign-extended properly in SPIR-V, so we can assume 32-bit values here.
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
statement("case ", to_case_label(case_literal, type.width, unsigned_case), label_suffix, ":");
GLSL: Implement switch on ESSL 1.0. Cannot use switch on legacy ESSL, fallback to plain branches.
2020-06-29 11:23:13 +00:00
}
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
}
}
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
auto &case_block = get<SPIRBlock>(target_block);
HLSL: Does not support case-fallthrough. Disable any fallthrough on HLSL. Risky business if fallthrough blocks had a barrier(), but can't do anything about that ...
2019-06-27 13:10:17 +00:00
if (backend.support_case_fallthrough && i + 1 < num_blocks &&
Run format_all.sh.
2019-06-21 14:02:22 +00:00
execution_is_direct_branch(case_block, get<SPIRBlock>(block_declaration_order[i + 1])))
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
{
// We will fall through here, so just terminate the block chain early.
// We still need to deal with Phi potentially.
// No need for a stack-like thing here since we only do fall-through when there is a
// single trivial branch to fall-through target..
current_emitting_switch_fallthrough = true;
}
else
current_emitting_switch_fallthrough = false;
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
if (!block_like_switch)
HLSL: Workaround FXC bugs with degenerate switch blocks. When we see a switch block which only contains one default block, emit a do {} while(false) statement instead, which is far more idiomatic and readable anyways.
2020-06-23 13:39:04 +00:00
begin_scope();
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
branch(block.self, target_block);
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
if (!block_like_switch)
HLSL: Workaround FXC bugs with degenerate switch blocks. When we see a switch block which only contains one default block, emit a do {} while(false) statement instead, which is far more idiomatic and readable anyways.
2020-06-23 13:39:04 +00:00
end_scope();
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
current_emitting_switch_fallthrough = false;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
// Might still have to flush phi variables if we branch from loop header directly to merge target.
Fix switch fallthrough case in some cases.
2021-08-31 15:24:09 +00:00
// This is supposed to emit all cases where we branch from header to merge block directly.
// There are two main scenarios where cannot rely on default fallthrough.
// - There is an explicit default: label already.
// In this case, literals_to_merge need to form their own "default" case, so that we avoid executing that block.
// - Header -> Merge requires flushing PHI. In this case, we need to collect all cases and flush PHI there.
bool header_merge_requires_phi = flush_phi_required(block.self, block.next_block);
bool need_fallthrough_block = block.default_block == block.next_block || !literals_to_merge.empty();
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
if (!collapsed_switch && ((header_merge_requires_phi && need_fallthrough_block) || !literals_to_merge.empty()))
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
Fix switch fallthrough case in some cases.
2021-08-31 15:24:09 +00:00
for (auto &case_literal : literals_to_merge)
MSL: Add 64 bit switch support Add 64 bit switch support for MSL version 2.2. * Also fixes a wrong endianness conversion. Signed-off-by: Sebastián Aedo <saedo@codeweavers.com>
2021-11-18 19:08:59 +00:00
statement("case ", to_case_label(case_literal, type.width, unsigned_case), label_suffix, ":");
Rewrite how switch block case labels are emitted.
2019-06-20 09:20:06 +00:00
Fix switch fallthrough case in some cases.
2021-08-31 15:24:09 +00:00
if (block.default_block == block.next_block)
{
GLSL: Convert switch blocks to if statements in legacy desktop versions
2024-09-08 12:46:00 +00:00
if (is_legacy())
Fix switch fallthrough case in some cases.
2021-08-31 15:24:09 +00:00
statement("else");
else
statement("default:");
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
}
Fix switch fallthrough case in some cases.
2021-08-31 15:24:09 +00:00
begin_scope();
flush_phi(block.self, block.next_block);
statement("break;");
end_scope();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
if (!collapsed_switch)
{
GLSL: Convert switch blocks to if statements in legacy desktop versions
2024-09-08 12:46:00 +00:00
if ((block_like_switch || is_legacy()) && !is_legacy_es())
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
end_scope_decl("while(false)");
else
end_scope();
}
HLSL: Workaround FXC bugs with degenerate switch blocks. When we see a switch block which only contains one default block, emit a do {} while(false) statement instead, which is far more idiomatic and readable anyways.
2020-06-23 13:39:04 +00:00
else
Handle PHI in collapsed switch constructs. Collapsed switch constructs only branch directly to the merge block.
2022-07-04 11:55:00 +00:00
flush_phi(block.self, block.next_block);
Deal with switch cases which break out of a loop. Need some pretty hideous ladder variable system, but high level languages do not support breaking out of a loop. break in switch blocks and break in loops alias each other.
2018-09-18 08:50:48 +00:00
if (block.need_ladder_break)
{
statement("if (_", block.self, "_ladder_break)");
begin_scope();
statement("break;");
end_scope();
}
Handle multiple breaks out of switches. Use a switch stack instead.
2022-07-22 13:29:48 +00:00
current_emitting_switch_stack.pop_back();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
}
case SPIRBlock::Return:
Move branchless analysis to CFG. Traverse backwards instead, far more robust. Should elide basically all redundant continue; statements now.
2019-08-26 13:36:23 +00:00
{
Make fixup_hooks more flexible. No reason why it needs to return a string. Callbacks can just do one or more statements themselves.
2018-09-17 12:04:55 +00:00
for (auto &line : current_function->fixup_hooks_out)
line();
CompilerMSL support matrices & arrays in stage-in & stage-out. Support flattening StorageOutput & StorageInput matrices and arrays. No longer move matrix & array inputs to separate buffer. Add separate SPIRFunction::fixup_statements_in & SPIRFunction::fixup_statements_out instead of just SPIRFunction::fixup_statements. Emit SPIRFunction::fixup_statements at beginning of functions. CompilerMSL track vars_needing_early_declaration. Pass global output variables as variables to functions that access them. Sort input structs by location, same as output structs. Emit struct declarations in order output, input, uniforms. Regenerate reference shaders to new formats defined by above.
2018-06-12 15:41:35 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (processing_entry_point)
emit_fixup();
Move branchless analysis to CFG. Traverse backwards instead, far more robust. Should elide basically all redundant continue; statements now.
2019-08-26 13:36:23 +00:00
auto &cfg = get_cfg_for_current_function();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (block.return_value)
{
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
auto &type = expression_type(block.return_value);
if (!type.array.empty() && !backend.can_return_array)
{
// If we cannot return arrays, we will have a special out argument we can write to instead.
// The backend is responsible for setting this up, and redirection the return values as appropriate.
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
if (ir.ids[block.return_value].get_type() != TypeUndef)
MSL: Deal with array copies from and to threadgroup.
2019-08-27 11:16:16 +00:00
{
MSL: Fix copy of arrays to/from stage IO variables. Need to take into account effective storage classes and whether or not we target stage IO blocks since native arrays are conditionally enabled.
2021-04-19 09:46:30 +00:00
emit_array_copy("spvReturnValue", 0, block.return_value, StorageClassFunction,
MSL: Deal with loading non-value-type arrays.
2020-06-18 10:46:39 +00:00
get_expression_effective_storage_class(block.return_value));
MSL: Deal with array copies from and to threadgroup.
2019-08-27 11:16:16 +00:00
}
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
Move branchless analysis to CFG. Traverse backwards instead, far more robust. Should elide basically all redundant continue; statements now.
2019-08-26 13:36:23 +00:00
if (!cfg.node_terminates_control_flow_in_sub_graph(current_function->entry_block, block.self) ||
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
block.loop_dominator != BlockID(SPIRBlock::NoDominator))
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
{
statement("return;");
}
}
else
{
// OpReturnValue can return Undef, so don't emit anything for this case.
Make meta a hashmap. A flat array was consuming way too much memory and was far too slow to initialize properly with a very large ID bound (8 million IDs, showed up as #1 hotspot in perf). Meta struct does not have to be in-order as we never iterate over it in a meaningful way, so using a hashmap here is reasonable. Very few IDs should need decorations or meta-data, so this should also be a quite decent memory save. For the pathological case, a 6x uplift was observed.
2019-01-10 13:04:01 +00:00
if (ir.ids[block.return_value].get_type() != TypeUndef)
MSL: Support more usecases for unpacked vectors. Additional usecases include array and vector indexing, variable declarations, loop initializers, function return values, switch statement evaluations, and various specialized MSL operations. Ultimately, we might consider refactoring CompilerMSL::to_expression() to always take into consideration possible unpacking behavior. Refactor CompilerGLSL::to_enclosed_unpacked_expression() for conciseness and consistency with similar functionality.
2021-10-21 20:11:33 +00:00
statement("return ", to_unpacked_expression(block.return_value), ";");
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Move branchless analysis to CFG. Traverse backwards instead, far more robust. Should elide basically all redundant continue; statements now.
2019-08-26 13:36:23 +00:00
else if (!cfg.node_terminates_control_flow_in_sub_graph(current_function->entry_block, block.self) ||
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
block.loop_dominator != BlockID(SPIRBlock::NoDominator))
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
{
Move branchless analysis to CFG. Traverse backwards instead, far more robust. Should elide basically all redundant continue; statements now.
2019-08-26 13:36:23 +00:00
// If this block is the very final block and not called from control flow,
// we do not need an explicit return which looks out of place. Just end the function here.
// In the very weird case of for(;;) { return; } executing return is unconditional,
// but we actually need a return here ...
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("return;");
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Move branchless analysis to CFG. Traverse backwards instead, far more robust. Should elide basically all redundant continue; statements now.
2019-08-26 13:36:23 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
MSL: Return fragment function value even when last SPIR-V Op is discard (OpKill). Add test shader for new functionality. Add legacy test reference shader for unrelated buffer-bitcast test, that doesn't seem to have been added previously.
2021-09-12 20:28:21 +00:00
// If the Kill is terminating a block with a (probably synthetic) return value, emit a return value statement.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
case SPIRBlock::Kill:
Compliance fixes for pull request. Use C++ style primitive casts. Add BackendVariations.discard_literal to support language variation for discard syntax. Tweaks to custom MSL defines.
2016-10-27 14:20:01 +00:00
statement(backend.discard_literal, ";");
MSL: Return fragment function value even when last SPIR-V Op is discard (OpKill). Add test shader for new functionality. Add legacy test reference shader for unrelated buffer-bitcast test, that doesn't seem to have been added previously.
2021-09-12 20:28:21 +00:00
if (block.return_value)
MSL: Support more usecases for unpacked vectors. Additional usecases include array and vector indexing, variable declarations, loop initializers, function return values, switch statement evaluations, and various specialized MSL operations. Ultimately, we might consider refactoring CompilerMSL::to_expression() to always take into consideration possible unpacking behavior. Refactor CompilerGLSL::to_enclosed_unpacked_expression() for conciseness and consistency with similar functionality.
2021-10-21 20:11:33 +00:00
statement("return ", to_unpacked_expression(block.return_value), ";");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
break;
Handle OpUnreachable in code-gen. Forgot to add it to emit_block_chain. It should just be a noop.
2018-01-15 08:35:09 +00:00
case SPIRBlock::Unreachable:
Promote Unreachable cases into break to avoid fallthrough. HLSL is very fussy about fallthrough in switch blocks, so promote Unreachable blocks to breaks if they are inside a switch construct. Some false positives are possible in weird multi-break scenarios, but this is benign.
2022-05-18 15:49:23 +00:00
{
// Avoid emitting false fallthrough, which can happen for
// if (cond) break; else discard; inside a case label.
// Discard is not always implementable as a terminator.
auto &cfg = get_cfg_for_current_function();
bool inner_dominator_is_switch = false;
ID id = block.self;
while (id)
{
auto &iter_block = get<SPIRBlock>(id);
if (iter_block.terminator == SPIRBlock::MultiSelect ||
iter_block.merge == SPIRBlock::MergeLoop)
{
ID next_block = iter_block.merge == SPIRBlock::MergeLoop ?
iter_block.merge_block : iter_block.next_block;
bool outside_construct = next_block && cfg.find_common_dominator(next_block, block.self) == next_block;
if (!outside_construct)
{
inner_dominator_is_switch = iter_block.terminator == SPIRBlock::MultiSelect;
break;
}
}
if (cfg.get_preceding_edges(id).empty())
break;
id = cfg.get_immediate_dominator(id);
}
if (inner_dominator_is_switch)
statement("break; // unreachable workaround");
Handle OpUnreachable in code-gen. Forgot to add it to emit_block_chain. It should just be a noop.
2018-01-15 08:35:09 +00:00
emit_next_block = false;
break;
Promote Unreachable cases into break to avoid fallthrough. HLSL is very fussy about fallthrough in switch blocks, so promote Unreachable blocks to breaks if they are inside a switch construct. Some false positives are possible in weird multi-break scenarios, but this is benign.
2022-05-18 15:49:23 +00:00
}
Handle OpUnreachable in code-gen. Forgot to add it to emit_block_chain. It should just be a noop.
2018-01-15 08:35:09 +00:00
GLSL: Support both SPV_KHR_ray_tracing and NV_ray_tracing. Fairly minor differences, so can keep them side by side without too much effort. NV support is effectively deprecated now however. - Add OpConvertUToAccelerationStructureKHR - Ignore/Terminate ray is now a terminator in KHR, but a call in NV. - Fix some bugs with reportIntersection.
2021-01-08 10:37:29 +00:00
case SPIRBlock::IgnoreIntersection:
statement("ignoreIntersectionEXT;");
break;
case SPIRBlock::TerminateRay:
statement("terminateRayEXT;");
break;
GLSL: Implement task shaders. Due to bugged glslang / spirv-tools w.r.t. terminator instructions, add a hack to ignore invalid SPIR-V for the time being.
2022-09-05 10:31:22 +00:00
case SPIRBlock::EmitMeshTasks:
virtual emit_mesh_tasks
2023-03-21 20:08:59 +00:00
emit_mesh_tasks(block);
GLSL: Implement task shaders. Due to bugged glslang / spirv-tools w.r.t. terminator instructions, add a hack to ignore invalid SPIR-V for the time being.
2022-09-05 10:31:22 +00:00
break;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
default:
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Unimplemented block terminator.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
if (block.next_block && emit_next_block)
{
// If we hit this case, we're dealing with an unconditional branch, which means we will output
// that block after this. If we had selection merge, we already flushed phi variables.
if (block.merge != SPIRBlock::MergeSelection)
Fix bug with control dependent expression tracking. For a direct branch without merge, we lost control dependent expressions.
2020-06-29 08:55:50 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
flush_phi(block.self, block.next_block);
Fix bug with control dependent expression tracking. For a direct branch without merge, we lost control dependent expressions.
2020-06-29 08:55:50 +00:00
// For a direct branch, need to remember to invalidate expressions in the next linear block instead.
get<SPIRBlock>(block.next_block).invalidate_expressions = block.invalidate_expressions;
}
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
// For switch fallthrough cases, we terminate the chain here, but we still need to handle Phi.
if (!current_emitting_switch_fallthrough)
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
{
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
// For merge selects we might have ignored the fact that a merge target
// could have been a break; or continue;
// We will need to deal with it here.
if (is_loop_break(block.next_block))
{
// Cannot check for just break, because switch statements will also use break.
assert(block.merge == SPIRBlock::MergeSelection);
statement("break;");
}
else if (is_continue(block.next_block))
{
assert(block.merge == SPIRBlock::MergeSelection);
branch_to_continue(block.self, block.next_block);
}
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
else if (BlockID(block.self) != block.next_block)
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
emit_block_chain(get<SPIRBlock>(block.next_block));
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
if (block.merge == SPIRBlock::MergeLoop)
{
if (continue_type == SPIRBlock::DoWhileLoop)
{
// Make sure that we run the continue block to get the expressions set, but this
// should become an empty string.
// We have no fallbacks if we cannot forward everything to temporaries ...
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
const auto &continue_block = get<SPIRBlock>(block.continue_block);
Run format_all.sh Disable clang format in C wrapper for now. Some weird formatting bug with the try/catch macro.
2019-03-06 11:20:13 +00:00
bool positive_test = execution_is_noop(get<SPIRBlock>(continue_block.true_block),
get<SPIRBlock>(continue_block.loop_dominator));
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
uint32_t current_count = statement_count;
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
auto statements = emit_continue_block(block.continue_block, positive_test, !positive_test);
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
if (statement_count != current_count)
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
{
// The DoWhile block has side effects, force ComplexLoop pattern next pass.
get<SPIRBlock>(block.continue_block).complex_continue = true;
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
force_recompile();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
// Might have to invert the do-while test here.
auto condition = to_expression(continue_block.condition);
if (!positive_test)
condition = join("!", enclose_expression(condition));
end_scope_decl(join("while (", condition, ")"));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
else
end_scope();
Implement context-sensitive expression read tracking. When inside a loop, treat any read of outer expressions to happen multiple times, forcing a temporary of said outer expressions. This avoids the problem where we can end up relying on loop-invariant code motion to happen in the compiler when converting optimized shaders.
2020-06-29 10:20:35 +00:00
loop_level_saver.release();
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
// We cannot break out of two loops at once, so don't check for break; here.
// Using block.self as the "from" block isn't quite right, but it has the same scope
// and dominance structure, so it's fine.
if (is_continue(block.merge_block))
branch_to_continue(block.self, block.merge_block);
else
emit_block_chain(get<SPIRBlock>(block.merge_block));
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
// Forget about control dependent expressions now.
block.invalidate_expressions.clear();
Deal with case where a block is somehow emitted in a duplicated fashion. We seen to have to deal with a case where a block is used multiple times without any "proper" structured control flow, so we risk losing deferred declaration state.
2019-06-05 10:35:30 +00:00
// After we return, we must be out of scope, so if we somehow have to re-emit this function,
// re-declare variables if necessary.
assert(rearm_dominated_variables.size() == block.dominated_variables.size());
for (size_t i = 0; i < block.dominated_variables.size(); i++)
{
uint32_t var = block.dominated_variables[i];
get<SPIRVariable>(var).deferred_declaration = rearm_dominated_variables[i];
}
Forget loop variable enables after emitting block chain.
2019-07-10 10:57:12 +00:00
// Just like for deferred declaration, we need to forget about loop variable enable
// if our block chain is reinstantiated later.
for (auto &var_id : block.loop_variables)
get<SPIRVariable>(var_id).loop_variable_enable = false;
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::begin_scope()
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
statement("{");
indent++;
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::end_scope()
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!indent)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Popping empty indent stack.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
indent--;
statement("}");
Initial commit.
2016-03-02 17:09:16 +00:00
}
MSL: Support dynamic offsets for buffers in argument buffers. Vulkan has two types of buffer descriptors, `VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC` and `VK_DESCRIPTOR_TYPE_STORAGE_BUFFER_DYNAMIC`, which allow the client to offset the buffers by an amount given when the descriptor set is bound to a pipeline. Metal provides no direct support for this when the buffer in question is in an argument buffer, so once again we're on our own. These offsets cannot be stored or associated in any way with the argument buffer itself, because they are set at bind time. Different pipelines may have different offsets set. Therefore, we must use a separate buffer, not in any argument buffer, to hold these offsets. Then the shader must manually offset the buffer pointer. This change fully supports arrays, including arrays of arrays, even though Vulkan forbids them. It does not, however, support runtime arrays. Perhaps later.
2019-09-06 04:14:12 +00:00
void CompilerGLSL::end_scope(const string &trailer)
{
if (!indent)
SPIRV_CROSS_THROW("Popping empty indent stack.");
indent--;
statement("}", trailer);
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::end_scope_decl()
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!indent)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Popping empty indent stack.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
indent--;
statement("};");
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::end_scope_decl(const string &decl)
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
if (!indent)
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Popping empty indent stack.");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
indent--;
statement("} ", decl, ";");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Add support for generic remapping of variables.
2016-07-06 09:04:06 +00:00
void CompilerGLSL::check_function_call_constraints(const uint32_t *args, uint32_t length)
{
// If our variable is remapped, and we rely on type-remapping information as
// well, then we cannot pass the variable as a function parameter.
// Fixing this is non-trivial without stamping out variants of the same function,
// so for now warn about this and suggest workarounds instead.
for (uint32_t i = 0; i < length; i++)
{
auto *var = maybe_get<SPIRVariable>(args[i]);
if (!var || !var->remapped_variable)
continue;
auto &type = get<SPIRType>(var->basetype);
if (type.basetype == SPIRType::Image && type.image.dim == DimSubpassData)
{
Add an option to disable exceptions Some refactoring in the no-exceptions case Grooming the no-exceptions patch for pull request
2016-12-12 21:33:22 +00:00
SPIRV_CROSS_THROW("Tried passing a remapped subpassInput variable to a function. "
"This will not work correctly because type-remapping information is lost. "
"To workaround, please consider not passing the subpass input as a function parameter, "
"or use in/out variables instead which do not need type remapping information.");
Add support for generic remapping of variables.
2016-07-06 09:04:06 +00:00
}
}
}
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
const Instruction *CompilerGLSL::get_next_instruction_in_block(const Instruction &instr)
{
// FIXME: This is kind of hacky. There should be a cleaner way.
auto offset = uint32_t(&instr - current_emitting_block->ops.data());
if ((offset + 1) < current_emitting_block->ops.size())
return &current_emitting_block->ops[offset + 1];
else
return nullptr;
}
Rewrite barrier handling in HLSL.
2018-01-09 11:41:13 +00:00
uint32_t CompilerGLSL::mask_relevant_memory_semantics(uint32_t semantics)
{
Formatting.
2018-01-09 11:51:21 +00:00
return semantics & (MemorySemanticsAtomicCounterMemoryMask | MemorySemanticsImageMemoryMask |
MemorySemanticsWorkgroupMemoryMask | MemorySemanticsUniformMemoryMask |
MemorySemanticsCrossWorkgroupMemoryMask | MemorySemanticsSubgroupMemoryMask);
Rewrite barrier handling in HLSL.
2018-01-09 11:41:13 +00:00
}
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
MSL: Handle more complex array copy scenarios with bool <-> short.
2023-06-06 13:05:56 +00:00
bool CompilerGLSL::emit_array_copy(const char *expr, uint32_t lhs_id, uint32_t rhs_id, StorageClass, StorageClass)
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
{
MSL: Handle more complex array copy scenarios with bool <-> short.
2023-06-06 13:05:56 +00:00
string lhs;
if (expr)
lhs = expr;
else
lhs = to_expression(lhs_id);
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
statement(lhs, " = ", to_expression(rhs_id), ";");
MSL: Handle stores to struct bool[].
2023-06-06 11:55:29 +00:00
return true;
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
}
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
bool CompilerGLSL::unroll_array_to_complex_store(uint32_t target_id, uint32_t source_id)
{
if (!backend.force_gl_in_out_block)
return false;
// This path is only relevant for GL backends.
auto *var = maybe_get<SPIRVariable>(target_id);
if (!var || var->storage != StorageClassOutput)
return false;
if (!is_builtin_variable(*var) || BuiltIn(get_decoration(var->self, DecorationBuiltIn)) != BuiltInSampleMask)
return false;
auto &type = expression_type(source_id);
string array_expr;
if (type.array_size_literal.back())
{
array_expr = convert_to_string(type.array.back());
if (type.array.back() == 0)
SPIRV_CROSS_THROW("Cannot unroll an array copy from unsized array.");
}
else
array_expr = to_expression(type.array.back());
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType target_type { OpTypeInt };
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
target_type.basetype = SPIRType::Int;
statement("for (int i = 0; i < int(", array_expr, "); i++)");
begin_scope();
statement(to_expression(target_id), "[i] = ",
bitcast_expression(target_type, type.basetype, join(to_expression(source_id), "[i]")),
";");
end_scope();
return true;
}
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
void CompilerGLSL::unroll_array_from_complex_load(uint32_t target_id, uint32_t source_id, std::string &expr)
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
{
if (!backend.force_gl_in_out_block)
return;
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
// This path is only relevant for GL backends.
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
auto *var = maybe_get<SPIRVariable>(source_id);
if (!var)
return;
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
if (var->storage != StorageClassInput && var->storage != StorageClassOutput)
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
return;
auto &type = get_variable_data_type(*var);
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
if (type.array.empty())
return;
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
auto builtin = BuiltIn(get_decoration(var->self, DecorationBuiltIn));
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
bool is_builtin = is_builtin_variable(*var) &&
(builtin == BuiltInPointSize ||
builtin == BuiltInPosition ||
builtin == BuiltInSampleMask);
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
bool is_tess = is_tessellation_shader();
GLSL: Fix array of input patch variables. Hoist out the hack to make array sizes unsized to a place where we can differentiate patch variables from control point variables.
2019-12-10 11:00:55 +00:00
bool is_patch = has_decoration(var->self, DecorationPatch);
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
bool is_sample_mask = is_builtin && builtin == BuiltInSampleMask;
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
// Tessellation input arrays are special in that they are unsized, so we cannot directly copy from it.
// We must unroll the array load.
// For builtins, we couldn't catch this case normally,
// because this is resolved in the OpAccessChain in most cases.
// If we load the entire array, we have no choice but to unroll here.
GLSL: Fix array of input patch variables. Hoist out the hack to make array sizes unsized to a place where we can differentiate patch variables from control point variables.
2019-12-10 11:00:55 +00:00
if (!is_patch && (is_builtin || is_tess))
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
{
auto new_expr = join("_", target_id, "_unrolled");
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
statement(variable_decl(type, new_expr, target_id), ";");
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
string array_expr;
GLSL: Fix issue with array-of-array inputs in tess. Only one dimension can be unsized and wrong dimension was used for unrolling purposes.
2019-11-04 09:33:52 +00:00
if (type.array_size_literal.back())
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
{
GLSL: Fix issue with array-of-array inputs in tess. Only one dimension can be unsized and wrong dimension was used for unrolling purposes.
2019-11-04 09:33:52 +00:00
array_expr = convert_to_string(type.array.back());
if (type.array.back() == 0)
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
SPIRV_CROSS_THROW("Cannot unroll an array copy from unsized array.");
}
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
else
GLSL: Fix issue with array-of-array inputs in tess. Only one dimension can be unsized and wrong dimension was used for unrolling purposes.
2019-11-04 09:33:52 +00:00
array_expr = to_expression(type.array.back());
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
// The array size might be a specialization constant, so use a for-loop instead.
statement("for (int i = 0; i < int(", array_expr, "); i++)");
begin_scope();
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
if (is_builtin && !is_sample_mask)
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
statement(new_expr, "[i] = gl_in[i].", expr, ";");
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
else if (is_sample_mask)
{
Various nit fixes and improvements from review.
2023-12-07 11:18:35 +00:00
SPIRType target_type { OpTypeInt };
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
target_type.basetype = SPIRType::Int;
statement(new_expr, "[i] = ", bitcast_expression(target_type, type.basetype, join(expr, "[i]")), ";");
}
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
else
statement(new_expr, "[i] = ", expr, "[i];");
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
end_scope();
Qualify std::move. Clang added -Wunqualified-std-cast-call in https://reviews.llvm.org/D119670, which warns on unqualified std::move and std::forward calls. This change qualifies these calls to allow the project to build on HEAD Clang -Werror.
2022-03-02 23:02:38 +00:00
expr = std::move(new_expr);
GLSL: Unroll loads from builtin pos/point arrays. Odd-ball case for certain geometry shaders coming from HLSL.
2019-03-21 10:25:41 +00:00
}
}
MSL: Workaround compiler crashes when using threadgroup bool. Promote to short instead and do simple casts on load/store instead. Not 100% complete fix since structs can contain booleans, but this is getting into pretty ridiculously complicated territory.
2021-10-25 08:55:11 +00:00
void CompilerGLSL::cast_from_variable_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type)
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
{
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
// We will handle array cases elsewhere.
if (!expr_type.array.empty())
return;
Bitcast loads from builtin compute variables.
2018-09-11 07:42:55 +00:00
auto *var = maybe_get_backing_variable(source_id);
if (var)
source_id = var->self;
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
// Only interested in standalone builtin variables.
if (!has_decoration(source_id, DecorationBuiltIn))
GLSL/HLSL: Add legacy handling for int vertex attributes
2023-01-14 17:56:54 +00:00
{
// Except for int attributes in legacy GLSL, which are cast from float.
if (is_legacy() && expr_type.basetype == SPIRType::Int && var && var->storage == StorageClassInput)
expr = join(type_to_glsl(expr_type), "(", expr, ")");
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
return;
GLSL/HLSL: Add legacy handling for int vertex attributes
2023-01-14 17:56:54 +00:00
}
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
auto builtin = static_cast<BuiltIn>(get_decoration(source_id, DecorationBuiltIn));
auto expected_type = expr_type.basetype;
// TODO: Fill in for more builtins.
switch (builtin)
{
case BuiltInLayer:
case BuiltInPrimitiveId:
case BuiltInViewportIndex:
case BuiltInInstanceId:
case BuiltInInstanceIndex:
case BuiltInVertexId:
case BuiltInVertexIndex:
case BuiltInSampleId:
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
case BuiltInBaseVertex:
case BuiltInBaseInstance:
case BuiltInDrawIndex:
GLSL: Support GL_ARB_shader_stencil_export.
2019-06-12 07:57:32 +00:00
case BuiltInFragStencilRefEXT:
GLSL: Add some more focused RT test shaders.
2020-05-20 11:14:23 +00:00
case BuiltInInstanceCustomIndexNV:
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
case BuiltInSampleMask:
GLSL: Support shading rate builtins.
2021-04-20 11:58:07 +00:00
case BuiltInPrimitiveShadingRateKHR:
case BuiltInShadingRateKHR:
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
expected_type = SPIRType::Int;
break;
Bitcast loads from builtin compute variables.
2018-09-11 07:42:55 +00:00
case BuiltInGlobalInvocationId:
case BuiltInLocalInvocationId:
case BuiltInWorkgroupId:
case BuiltInLocalInvocationIndex:
case BuiltInWorkgroupSize:
case BuiltInNumWorkgroups:
GLSL: Add some more focused RT test shaders.
2020-05-20 11:14:23 +00:00
case BuiltInIncomingRayFlagsNV:
case BuiltInLaunchIdNV:
case BuiltInLaunchSizeNV:
GLSL: Implement GL_EXT_mesh_shader.
2022-09-02 14:31:04 +00:00
case BuiltInPrimitiveTriangleIndicesEXT:
case BuiltInPrimitiveLineIndicesEXT:
case BuiltInPrimitivePointIndicesEXT:
Bitcast loads from builtin compute variables.
2018-09-11 07:42:55 +00:00
expected_type = SPIRType::UInt;
break;
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
default:
break;
}
if (expected_type != expr_type.basetype)
expr = bitcast_expression(expr_type, expected_type, expr);
}
Fix declaration of gl_SampleMaskIn[1] in HLSL backend.
2023-10-04 20:34:52 +00:00
SPIRType::BaseType CompilerGLSL::get_builtin_basetype(BuiltIn builtin, SPIRType::BaseType default_type)
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
{
// TODO: Fill in for more builtins.
switch (builtin)
{
case BuiltInLayer:
case BuiltInPrimitiveId:
case BuiltInViewportIndex:
GLSL: Support GL_ARB_shader_stencil_export.
2019-06-12 07:57:32 +00:00
case BuiltInFragStencilRefEXT:
GLSL: Handle complex load/store scenarios to gl_SampleMask. Need special workarounds to handle array load/store since array size is unsized in GLSL, and array copy is not possible. Also, consider bitcast for scalar loads and stores.
2021-03-08 10:51:51 +00:00
case BuiltInSampleMask:
GLSL: Support shading rate builtins.
2021-04-20 11:58:07 +00:00
case BuiltInPrimitiveShadingRateKHR:
case BuiltInShadingRateKHR:
Fix declaration of gl_SampleMaskIn[1] in HLSL backend.
2023-10-04 20:34:52 +00:00
return SPIRType::Int;
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
default:
Fix declaration of gl_SampleMaskIn[1] in HLSL backend.
2023-10-04 20:34:52 +00:00
return default_type;
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
}
Fix declaration of gl_SampleMaskIn[1] in HLSL backend.
2023-10-04 20:34:52 +00:00
}
void CompilerGLSL::cast_to_variable_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type)
{
auto *var = maybe_get_backing_variable(target_id);
if (var)
target_id = var->self;
// Only interested in standalone builtin variables.
if (!has_decoration(target_id, DecorationBuiltIn))
return;
auto builtin = static_cast<BuiltIn>(get_decoration(target_id, DecorationBuiltIn));
auto expected_type = get_builtin_basetype(builtin, expr_type.basetype);
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
if (expected_type != expr_type.basetype)
{
auto type = expr_type;
type.basetype = expected_type;
expr = bitcast_expression(type, expr_type.basetype, expr);
}
}
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
void CompilerGLSL::convert_non_uniform_expression(string &expr, uint32_t ptr_id)
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
{
HLSL/MSL: Deal correctly with nonuniformEXT qualifier. MSL does not seem to have a qualifier for this, but HLSL SM 5.1 does. glslangValidator for HLSL does not support this, so skip any validation, but it passes in FXC.
2019-05-13 12:58:27 +00:00
if (*backend.nonuniform_qualifier == '\0')
return;
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
auto *var = maybe_get_backing_variable(ptr_id);
if (!var)
return;
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
if (var->storage != StorageClassUniformConstant &&
var->storage != StorageClassStorageBuffer &&
var->storage != StorageClassUniform)
return;
GLSL: Fix nonuniformEXT injection. Needs to consider that other expressions might be using brackets as well ...
2020-10-30 12:45:15 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
auto &backing_type = get<SPIRType>(var->basetype);
if (backing_type.array.empty())
return;
GLSL: Fix nonuniformEXT injection. Needs to consider that other expressions might be using brackets as well ...
2020-10-30 12:45:15 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
// If we get here, we know we're accessing an arrayed resource which
// might require nonuniform qualifier.
auto start_array_index = expr.find_first_of('[');
if (start_array_index == string::npos)
return;
GLSL: Fix nonuniformEXT injection. Needs to consider that other expressions might be using brackets as well ...
2020-10-30 12:45:15 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
// We've opened a bracket, track expressions until we can close the bracket.
// This must be our resource index.
size_t end_array_index = string::npos;
unsigned bracket_count = 1;
for (size_t index = start_array_index + 1; index < expr.size(); index++)
{
if (expr[index] == ']')
GLSL: Fix nonuniformEXT injection. Needs to consider that other expressions might be using brackets as well ...
2020-10-30 12:45:15 +00:00
{
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
if (--bracket_count == 0)
GLSL: Fix nonuniformEXT injection. Needs to consider that other expressions might be using brackets as well ...
2020-10-30 12:45:15 +00:00
{
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
end_array_index = index;
break;
GLSL: Fix nonuniformEXT injection. Needs to consider that other expressions might be using brackets as well ...
2020-10-30 12:45:15 +00:00
}
}
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
else if (expr[index] == '[')
bracket_count++;
}
GLSL: Fix nonuniformEXT injection. Needs to consider that other expressions might be using brackets as well ...
2020-10-30 12:45:15 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
assert(bracket_count == 0);
GLSL: Fix nonuniformEXT injection. Needs to consider that other expressions might be using brackets as well ...
2020-10-30 12:45:15 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
// Doesn't really make sense to declare a non-arrayed image with nonuniformEXT, but there's
// nothing we can do here to express that.
if (start_array_index == string::npos || end_array_index == string::npos || end_array_index < start_array_index)
return;
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
start_array_index++;
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
Rewrite how non-uniform qualifiers are handled. Remove all shenanigans with propagation, and only consume nonuniform qualifiers exactly where needed (last minute).
2021-04-22 11:54:43 +00:00
expr = join(expr.substr(0, start_array_index), backend.nonuniform_qualifier, "(",
expr.substr(start_array_index, end_array_index - start_array_index), ")",
expr.substr(end_array_index, string::npos));
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
}
GLSL: Implement control flow hints.
2021-06-03 10:00:29 +00:00
void CompilerGLSL::emit_block_hints(const SPIRBlock &block)
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +00:00
{
GLSL: Implement control flow hints.
2021-06-03 10:00:29 +00:00
if ((options.es && options.version < 310) || (!options.es && options.version < 140))
return;
switch (block.hint)
{
case SPIRBlock::HintFlatten:
require_extension_internal("GL_EXT_control_flow_attributes");
statement("SPIRV_CROSS_FLATTEN");
break;
case SPIRBlock::HintDontFlatten:
require_extension_internal("GL_EXT_control_flow_attributes");
statement("SPIRV_CROSS_BRANCH");
break;
case SPIRBlock::HintUnroll:
require_extension_internal("GL_EXT_control_flow_attributes");
statement("SPIRV_CROSS_UNROLL");
break;
case SPIRBlock::HintDontUnroll:
require_extension_internal("GL_EXT_control_flow_attributes");
statement("SPIRV_CROSS_LOOP");
break;
default:
break;
}
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +00:00
}
GLSL: Fix block name shenanigans in edge cases. When we force recompile, the old var.self name we used as a fallback name might have been disturbed, so we should recover certain names back to their original form in case we are forced to take a recompile to make the naming algorithm more deterministic.
2019-02-13 15:39:59 +00:00
void CompilerGLSL::preserve_alias_on_reset(uint32_t id)
{
preserved_aliases[id] = get_name(id);
}
void CompilerGLSL::reset_name_caches()
{
for (auto &preserved : preserved_aliases)
set_name(preserved.first, preserved.second);
preserved_aliases.clear();
resource_names.clear();
block_input_names.clear();
block_output_names.clear();
block_ubo_names.clear();
block_ssbo_names.clear();
block_names.clear();
function_overloads.clear();
}
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
Fixup names of anonymous inner structs. Just like we try to fixup struct names for block types, inner structs can be "anonymous" structs. HLSL codegen from DXC tends to emit this, and emitting dummy struct names tends to break GL linkage on some drivers.
2022-03-10 14:38:57 +00:00
void CompilerGLSL::fixup_anonymous_struct_names(std::unordered_set<uint32_t> &visited, const SPIRType &type)
{
if (visited.count(type.self))
return;
visited.insert(type.self);
for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++)
{
auto &mbr_type = get<SPIRType>(type.member_types[i]);
if (mbr_type.basetype == SPIRType::Struct)
{
// If there are multiple aliases, the output might be somewhat unpredictable,
// but the only real alternative in that case is to do nothing, which isn't any better.
// This check should be fine in practice.
if (get_name(mbr_type.self).empty() && !get_member_name(type.self, i).empty())
{
auto anon_name = join("anon_", get_member_name(type.self, i));
ParsedIR::sanitize_underscores(anon_name);
set_name(mbr_type.self, anon_name);
}
fixup_anonymous_struct_names(visited, mbr_type);
}
}
}
void CompilerGLSL::fixup_anonymous_struct_names()
{
// HLSL codegen can often end up emitting anonymous structs inside blocks, which
// breaks GL linking since all names must match ...
// Try to emit sensible code, so attempt to find such structs and emit anon_$member.
// Breaks exponential explosion with weird type trees.
std::unordered_set<uint32_t> visited;
ir.for_each_typed_id<SPIRType>([&](uint32_t, SPIRType &type) {
if (type.basetype == SPIRType::Struct &&
(has_decoration(type.self, DecorationBlock) ||
has_decoration(type.self, DecorationBufferBlock)))
{
fixup_anonymous_struct_names(visited, type);
}
});
}
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
void CompilerGLSL::fixup_type_alias()
{
// Due to how some backends work, the "master" type of type_alias must be a block-like type if it exists.
ir.for_each_typed_id<SPIRType>([&](uint32_t self, SPIRType &type) {
GLSL: Be more aggressive about using type_alias. To facilitate an improved linking-by-name use case for older GL, we will be more aggressive about merging struct definitions, even for rather unrelated cases where we don't strictly need to use type aliases.
2020-07-29 09:58:32 +00:00
if (!type.type_alias)
return;
if (has_decoration(type.self, DecorationBlock) || has_decoration(type.self, DecorationBufferBlock))
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
{
GLSL: Be more aggressive about using type_alias. To facilitate an improved linking-by-name use case for older GL, we will be more aggressive about merging struct definitions, even for rather unrelated cases where we don't strictly need to use type aliases.
2020-07-29 09:58:32 +00:00
// Top-level block types should never alias anything else.
type.type_alias = 0;
}
else if (type_is_block_like(type) && type.self == ID(self))
{
// A block-like type is any type which contains Offset decoration, but not top-level blocks,
// i.e. blocks which are placed inside buffers.
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
// Become the master.
ir.for_each_typed_id<SPIRType>([&](uint32_t other_id, SPIRType &other_type) {
Only rewrite type aliases for the base type.
2020-07-29 09:21:13 +00:00
if (other_id == self)
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
return;
if (other_type.type_alias == type.type_alias)
Only rewrite type aliases for the base type.
2020-07-29 09:21:13 +00:00
other_type.type_alias = self;
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
});
this->get<SPIRType>(type.type_alias).type_alias = self;
type.type_alias = 0;
}
});
}
void CompilerGLSL::reorder_type_alias()
{
// Reorder declaration of types so that the master of the type alias is always emitted first.
// We need this in case a type B depends on type A (A must come before in the vector), but A is an alias of a type Abuffer, which
// means declaration of A doesn't happen (yet), and order would be B, ABuffer and not ABuffer, B. Fix this up here.
Start considering how to emit physical type ID.
2019-07-18 15:05:28 +00:00
auto loop_lock = ir.create_loop_hard_lock();
MSL: Begin rewrite of buffer packing logic.
2019-07-18 11:34:47 +00:00
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
auto &type_ids = ir.ids_for_type[TypeType];
for (auto alias_itr = begin(type_ids); alias_itr != end(type_ids); ++alias_itr)
{
auto &type = get<SPIRType>(*alias_itr);
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
if (type.type_alias != TypeID(0) &&
!has_extended_decoration(type.type_alias, SPIRVCrossDecorationBufferBlockRepacked))
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
{
// We will skip declaring this type, so make sure the type_alias type comes before.
Refactor into stronger types in public API. Some fallout where internal functions are using stronger types. Overkill to move everything over to strong types right now, but perhaps move over to it slowly over time.
2019-09-05 10:43:40 +00:00
auto master_itr = find(begin(type_ids), end(type_ids), ID(type.type_alias));
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
assert(master_itr != end(type_ids));
if (alias_itr < master_itr)
{
// Must also swap the type order for the constant-type joined array.
Interleave undef values with constants and types. Undef values may be of struct type and may be used in constants. Therefore, they must be interleaved with constants and types. Fixes the rest of the Vulkan CTS test `dEQP-VK.spirv_assembly.instruction.compute.opundef.undefined_spec_constant_composite`. (Please excuse the churn in the reference output; it's an inevitable result of this change.)
2022-11-09 04:04:36 +00:00
auto &joined_types = ir.ids_for_constant_undef_or_type;
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
auto alt_alias_itr = find(begin(joined_types), end(joined_types), *alias_itr);
auto alt_master_itr = find(begin(joined_types), end(joined_types), *master_itr);
assert(alt_alias_itr != end(joined_types));
assert(alt_master_itr != end(joined_types));
swap(*alias_itr, *master_itr);
swap(*alt_alias_itr, *alt_master_itr);
}
}
}
}
Support emitting OpLine directive. Facilitates easier mapping from source language to cross-compiled output in tooling.
2019-05-28 11:41:46 +00:00
void CompilerGLSL::emit_line_directive(uint32_t file_id, uint32_t line_literal)
{
// If we are redirecting statements, ignore the line directive.
// Common case here is continue blocks.
if (redirect_statement)
return;
Skip line directives when emitting loop condition blocks. Avoids problem where enabling line directives breaks loop optimizations since it thinks there are legitimate statements in the block.
2023-06-12 10:33:58 +00:00
// If we're emitting code in a sensitive context such as condition blocks in for loops, don't emit
// any line directives, because it's not possible.
if (block_debug_directives)
return;
Support emitting OpLine directive. Facilitates easier mapping from source language to cross-compiled output in tooling.
2019-05-28 11:41:46 +00:00
if (options.emit_line_directives)
{
require_extension_internal("GL_GOOGLE_cpp_style_line_directive");
statement_no_indent("#line ", line_literal, " \"", get<SPIRString>(file_id).str, "\"");
}
}
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
Run format_all.sh.
2020-01-08 09:48:30 +00:00
void CompilerGLSL::emit_copy_logical_type(uint32_t lhs_id, uint32_t lhs_type_id, uint32_t rhs_id, uint32_t rhs_type_id,
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
SmallVector<uint32_t> chain)
Basic implementation of OpCopyLogical.
2020-01-06 10:47:26 +00:00
{
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
// Fully unroll all member/array indices one by one.
auto &lhs_type = get<SPIRType>(lhs_type_id);
auto &rhs_type = get<SPIRType>(rhs_type_id);
Basic implementation of OpCopyLogical.
2020-01-06 10:47:26 +00:00
if (!lhs_type.array.empty())
{
// Could use a loop here to support specialization constants, but it gets rather complicated with nested array types,
// and this is a rather obscure opcode anyways, keep it simple unless we are forced to.
uint32_t array_size = to_array_size_literal(lhs_type);
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
chain.push_back(0);
Basic implementation of OpCopyLogical.
2020-01-06 10:47:26 +00:00
for (uint32_t i = 0; i < array_size; i++)
{
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
chain.back() = i;
emit_copy_logical_type(lhs_id, lhs_type.parent_type, rhs_id, rhs_type.parent_type, chain);
Basic implementation of OpCopyLogical.
2020-01-06 10:47:26 +00:00
}
}
else if (lhs_type.basetype == SPIRType::Struct)
{
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
chain.push_back(0);
Basic implementation of OpCopyLogical.
2020-01-06 10:47:26 +00:00
uint32_t member_count = uint32_t(lhs_type.member_types.size());
for (uint32_t i = 0; i < member_count; i++)
{
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
chain.back() = i;
emit_copy_logical_type(lhs_id, lhs_type.member_types[i], rhs_id, rhs_type.member_types[i], chain);
Basic implementation of OpCopyLogical.
2020-01-06 10:47:26 +00:00
}
}
else
{
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
// Need to handle unpack/packing fixups since this can differ wildly between the logical types,
// particularly in MSL.
// To deal with this, we emit access chains and go through emit_store_statement
// to deal with all the special cases we can encounter.
AccessChainMeta lhs_meta, rhs_meta;
Run format_all.sh.
2020-01-08 09:48:30 +00:00
auto lhs = access_chain_internal(lhs_id, chain.data(), uint32_t(chain.size()),
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &lhs_meta);
auto rhs = access_chain_internal(rhs_id, chain.data(), uint32_t(chain.size()),
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &rhs_meta);
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
uint32_t id = ir.increase_bound_by(2);
lhs_id = id;
rhs_id = id + 1;
{
Qualify std::move. Clang added -Wunqualified-std-cast-call in https://reviews.llvm.org/D119670, which warns on unqualified std::move and std::forward calls. This change qualifies these calls to allow the project to build on HEAD Clang -Werror.
2022-03-02 23:02:38 +00:00
auto &lhs_expr = set<SPIRExpression>(lhs_id, std::move(lhs), lhs_type_id, true);
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
lhs_expr.need_transpose = lhs_meta.need_transpose;
if (lhs_meta.storage_is_packed)
set_extended_decoration(lhs_id, SPIRVCrossDecorationPhysicalTypePacked);
if (lhs_meta.storage_physical_type != 0)
set_extended_decoration(lhs_id, SPIRVCrossDecorationPhysicalTypeID, lhs_meta.storage_physical_type);
forwarded_temporaries.insert(lhs_id);
suppressed_usage_tracking.insert(lhs_id);
}
{
Qualify std::move. Clang added -Wunqualified-std-cast-call in https://reviews.llvm.org/D119670, which warns on unqualified std::move and std::forward calls. This change qualifies these calls to allow the project to build on HEAD Clang -Werror.
2022-03-02 23:02:38 +00:00
auto &rhs_expr = set<SPIRExpression>(rhs_id, std::move(rhs), rhs_type_id, true);
Go through access chain path for OpCopyLogical. We will need to deal with packing/unpacking data when copying from/to complex types in MSL.
2020-01-06 11:29:44 +00:00
rhs_expr.need_transpose = rhs_meta.need_transpose;
if (rhs_meta.storage_is_packed)
set_extended_decoration(rhs_id, SPIRVCrossDecorationPhysicalTypePacked);
if (rhs_meta.storage_physical_type != 0)
set_extended_decoration(rhs_id, SPIRVCrossDecorationPhysicalTypeID, rhs_meta.storage_physical_type);
forwarded_temporaries.insert(rhs_id);
suppressed_usage_tracking.insert(rhs_id);
}
emit_store_statement(lhs_id, rhs_id);
Basic implementation of OpCopyLogical.
2020-01-06 10:47:26 +00:00
}
}
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
bool CompilerGLSL::subpass_input_is_framebuffer_fetch(uint32_t id) const
{
if (!has_decoration(id, DecorationInputAttachmentIndex))
return false;
uint32_t input_attachment_index = get_decoration(id, DecorationInputAttachmentIndex);
for (auto &remap : subpass_to_framebuffer_fetch_attachment)
if (remap.first == input_attachment_index)
return true;
return false;
}
const SPIRVariable *CompilerGLSL::find_subpass_input_by_attachment_index(uint32_t index) const
{
const SPIRVariable *ret = nullptr;
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, const SPIRVariable &var) {
if (has_decoration(var.self, DecorationInputAttachmentIndex) &&
get_decoration(var.self, DecorationInputAttachmentIndex) == index)
{
ret = &var;
}
});
return ret;
}
const SPIRVariable *CompilerGLSL::find_color_output_by_location(uint32_t location) const
{
const SPIRVariable *ret = nullptr;
ir.for_each_typed_id<SPIRVariable>([&](uint32_t, const SPIRVariable &var) {
if (var.storage == StorageClassOutput && get_decoration(var.self, DecorationLocation) == location)
ret = &var;
});
return ret;
}
void CompilerGLSL::emit_inout_fragment_outputs_copy_to_subpass_inputs()
{
for (auto &remap : subpass_to_framebuffer_fetch_attachment)
{
auto *subpass_var = find_subpass_input_by_attachment_index(remap.first);
auto *output_var = find_color_output_by_location(remap.second);
if (!subpass_var)
continue;
if (!output_var)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
SPIRV_CROSS_THROW("Need to declare the corresponding fragment output variable to be able "
"to read from it.");
GLSL: Implement GL_EXT_shader_framebuffer_fetch.
2020-03-19 13:20:37 +00:00
if (is_array(get<SPIRType>(output_var->basetype)))
SPIRV_CROSS_THROW("Cannot use GL_EXT_shader_framebuffer_fetch with arrays of color outputs.");
auto &func = get<SPIRFunction>(get_entry_point().self);
func.fixup_hooks_in.push_back([=]() {
if (is_legacy())
{
statement(to_expression(subpass_var->self), " = ", "gl_LastFragData[",
get_decoration(output_var->self, DecorationLocation), "];");
}
else
{
uint32_t num_rt_components = this->get<SPIRType>(output_var->basetype).vecsize;
statement(to_expression(subpass_var->self), vector_swizzle(num_rt_components, 0), " = ",
to_expression(output_var->self), ";");
}
});
}
}
Expose a query if samplers or images are comparison resources.
2020-04-03 10:26:42 +00:00
bool CompilerGLSL::variable_is_depth_or_compare(VariableID id) const
{
Separate (partially) the tracking of depth images from depth compare ops. SPIR-V allows an image to be marked as a depth image, but with a non-depth format. Such images should be read or sampled as vectors instead of scalars, except when they are subject to compare operations. Don't mark an OpSampledImage as using a compare operation just because the image contains a depth marker. Instead, require that a compare operation is actually used on that image. Compiler::image_is_comparison() was really testing whether an image is a depth image, since it incorporates the depth marker. Rename that function to is_depth_image(), to clarify what it is really testing. In Compiler::is_depth_image(), do not treat an image as a depth image if it has been explicitly marked with a color format, unless the image is subject to compare operations. In CompilerMSL::to_function_name(), test for compare operations specifically, rather than assuming them from the depth-image marker. CompilerGLSL and CompilerMSL still contain a number of internal tests that use is_depth_image() both for testing for a depth image, and for testing whether compare operations are being used. I've left these as they are for now, but these should be cleaned up at some point. Add unit tests for fetch/sample depth images with color formats and no compare ops.
2021-11-08 20:59:45 +00:00
return is_depth_image(get<SPIRType>(get<SPIRVariable>(id).basetype), id);
Expose a query if samplers or images are comparison resources.
2020-04-03 10:26:42 +00:00
}
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *CompilerGLSL::ShaderSubgroupSupportHelper::get_extension_name(Candidate c)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Run format_all.sh.
2020-11-08 12:59:52 +00:00
static const char *const retval[CandidateCount] = { "GL_KHR_shader_subgroup_ballot",
"GL_KHR_shader_subgroup_basic",
"GL_KHR_shader_subgroup_vote",
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
"GL_KHR_shader_subgroup_arithmetic",
Run format_all.sh.
2020-11-08 12:59:52 +00:00
"GL_NV_gpu_shader_5",
"GL_NV_shader_thread_group",
"GL_NV_shader_thread_shuffle",
"GL_ARB_shader_ballot",
"GL_ARB_shader_group_vote",
"GL_AMD_gcn_shader" };
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
return retval[c];
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
SmallVector<std::string> CompilerGLSL::ShaderSubgroupSupportHelper::get_extra_required_extension_names(Candidate c)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
switch (c)
{
case ARB_shader_ballot:
return { "GL_ARB_shader_int64" };
case AMD_gcn_shader:
return { "GL_AMD_gpu_shader_int64", "GL_NV_gpu_shader5" };
default:
return {};
}
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
const char *CompilerGLSL::ShaderSubgroupSupportHelper::get_extra_required_extension_predicate(Candidate c)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
switch (c)
{
case ARB_shader_ballot:
return "defined(GL_ARB_shader_int64)";
case AMD_gcn_shader:
return "(defined(GL_AMD_gpu_shader_int64) || defined(GL_NV_gpu_shader5))";
default:
return "";
}
}
Run format_all.sh.
2020-11-08 12:59:52 +00:00
CompilerGLSL::ShaderSubgroupSupportHelper::FeatureVector CompilerGLSL::ShaderSubgroupSupportHelper::
get_feature_dependencies(Feature feature)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
switch (feature)
{
case SubgroupAllEqualT:
GLSL: Fix KHR subgroup extension table for subgroups.
2020-12-11 11:24:34 +00:00
return { SubgroupBroadcast_First, SubgroupAll_Any_AllEqualBool };
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
case SubgroupElect:
return { SubgroupBallotFindLSB_MSB, SubgroupBallot, SubgroupInvocationID };
case SubgroupInverseBallot_InclBitCount_ExclBitCout:
return { SubgroupMask };
case SubgroupBallotBitCount:
return { SubgroupBallot };
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
case SubgroupArithmeticIAddReduce:
GLSL: Support KHR_subgroup_arithmetic FAdd Support NV workarounds for FAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-02 07:45:25 +00:00
case SubgroupArithmeticIAddInclusiveScan:
case SubgroupArithmeticFAddReduce:
case SubgroupArithmeticFAddInclusiveScan:
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
case SubgroupArithmeticIMulReduce:
case SubgroupArithmeticIMulInclusiveScan:
case SubgroupArithmeticFMulReduce:
case SubgroupArithmeticFMulInclusiveScan:
GLSL: Checking for inactive threads in non uniform arithmetic ops The last argument of shuffle*NV functions does not return if the current thread is inactive, but only if it is out of range.
2023-04-03 15:42:08 +00:00
return { SubgroupSize, SubgroupBallot, SubgroupBallotBitCount, SubgroupMask, SubgroupBallotBitExtract };
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
case SubgroupArithmeticIAddExclusiveScan:
GLSL: Support KHR_subgroup_arithmetic FAdd Support NV workarounds for FAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-02 07:45:25 +00:00
case SubgroupArithmeticFAddExclusiveScan:
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
case SubgroupArithmeticIMulExclusiveScan:
case SubgroupArithmeticFMulExclusiveScan:
GLSL: Checking for inactive threads in non uniform arithmetic ops The last argument of shuffle*NV functions does not return if the current thread is inactive, but only if it is out of range.
2023-04-03 15:42:08 +00:00
return { SubgroupSize, SubgroupBallot, SubgroupBallotBitCount,
SubgroupMask, SubgroupElect, SubgroupBallotBitExtract };
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
default:
return {};
}
}
Run format_all.sh.
2020-11-08 12:59:52 +00:00
CompilerGLSL::ShaderSubgroupSupportHelper::FeatureMask CompilerGLSL::ShaderSubgroupSupportHelper::
get_feature_dependency_mask(Feature feature)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
return build_mask(get_feature_dependencies(feature));
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
bool CompilerGLSL::ShaderSubgroupSupportHelper::can_feature_be_implemented_without_extensions(Feature feature)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
static const bool retval[FeatureCount] = {
false, false, false, false, false, false,
true, // SubgroupBalloFindLSB_MSB
false, false, false, false,
true, // SubgroupMemBarrier - replaced with workgroup memory barriers
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
false, false, true, false,
false, false, false, false, false, false, // iadd, fadd
false, false, false, false, false, false, // imul , fmul
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
};
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
return retval[feature];
}
Run format_all.sh.
2020-11-08 12:59:52 +00:00
CompilerGLSL::ShaderSubgroupSupportHelper::Candidate CompilerGLSL::ShaderSubgroupSupportHelper::
get_KHR_extension_for_feature(Feature feature)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
static const Candidate extensions[FeatureCount] = {
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
KHR_shader_subgroup_ballot, KHR_shader_subgroup_basic, KHR_shader_subgroup_basic, KHR_shader_subgroup_basic,
KHR_shader_subgroup_basic, KHR_shader_subgroup_ballot, KHR_shader_subgroup_ballot, KHR_shader_subgroup_vote,
GLSL: Fix KHR subgroup extension table for subgroups.
2020-12-11 11:24:34 +00:00
KHR_shader_subgroup_vote, KHR_shader_subgroup_basic, KHR_shader_subgroup_basic, KHR_shader_subgroup_basic,
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
KHR_shader_subgroup_ballot, KHR_shader_subgroup_ballot, KHR_shader_subgroup_ballot, KHR_shader_subgroup_ballot,
KHR_shader_subgroup_arithmetic, KHR_shader_subgroup_arithmetic, KHR_shader_subgroup_arithmetic,
GLSL: Support KHR_subgroup_arithmetic FAdd Support NV workarounds for FAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-02 07:45:25 +00:00
KHR_shader_subgroup_arithmetic, KHR_shader_subgroup_arithmetic, KHR_shader_subgroup_arithmetic,
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
KHR_shader_subgroup_arithmetic, KHR_shader_subgroup_arithmetic, KHR_shader_subgroup_arithmetic,
KHR_shader_subgroup_arithmetic, KHR_shader_subgroup_arithmetic, KHR_shader_subgroup_arithmetic,
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
};
return extensions[feature];
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
void CompilerGLSL::ShaderSubgroupSupportHelper::request_feature(Feature feature)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
feature_mask |= (FeatureMask(1) << feature) | get_feature_dependency_mask(feature);
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
bool CompilerGLSL::ShaderSubgroupSupportHelper::is_feature_requested(Feature feature) const
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
return (feature_mask & (1u << feature)) != 0;
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
Run format_all.sh.
2020-11-08 12:59:52 +00:00
CompilerGLSL::ShaderSubgroupSupportHelper::Result CompilerGLSL::ShaderSubgroupSupportHelper::resolve() const
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Result res;
for (uint32_t i = 0u; i < FeatureCount; ++i)
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
if (feature_mask & (1u << i))
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
auto feature = static_cast<Feature>(i);
std::unordered_set<uint32_t> unique_candidates;
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
auto candidates = get_candidates_for_feature(feature);
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
unique_candidates.insert(candidates.begin(), candidates.end());
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
auto deps = get_feature_dependencies(feature);
for (Feature d : deps)
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
{
candidates = get_candidates_for_feature(d);
if (!candidates.empty())
unique_candidates.insert(candidates.begin(), candidates.end());
}
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (uint32_t c : unique_candidates)
++res.weights[static_cast<Candidate>(c)];
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
}
return res;
}
Run format_all.sh.
2020-11-08 12:59:52 +00:00
CompilerGLSL::ShaderSubgroupSupportHelper::CandidateVector CompilerGLSL::ShaderSubgroupSupportHelper::
get_candidates_for_feature(Feature ft, const Result &r)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
auto c = get_candidates_for_feature(ft);
auto cmp = [&r](Candidate a, Candidate b) {
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
if (r.weights[a] == r.weights[b])
return a < b; // Prefer candidates with lower enum value
return r.weights[a] > r.weights[b];
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
};
std::sort(c.begin(), c.end(), cmp);
return c;
}
Run format_all.sh.
2020-11-08 12:59:52 +00:00
CompilerGLSL::ShaderSubgroupSupportHelper::CandidateVector CompilerGLSL::ShaderSubgroupSupportHelper::
get_candidates_for_feature(Feature feature)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
switch (feature)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
case SubgroupMask:
return { KHR_shader_subgroup_ballot, NV_shader_thread_group, ARB_shader_ballot };
case SubgroupSize:
return { KHR_shader_subgroup_basic, NV_shader_thread_group, AMD_gcn_shader, ARB_shader_ballot };
case SubgroupInvocationID:
return { KHR_shader_subgroup_basic, NV_shader_thread_group, ARB_shader_ballot };
case SubgroupID:
return { KHR_shader_subgroup_basic, NV_shader_thread_group };
case NumSubgroups:
return { KHR_shader_subgroup_basic, NV_shader_thread_group };
GLSL: Fix KHR subgroup extension table for subgroups.
2020-12-11 11:24:34 +00:00
case SubgroupBroadcast_First:
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
return { KHR_shader_subgroup_ballot, NV_shader_thread_shuffle, ARB_shader_ballot };
case SubgroupBallotFindLSB_MSB:
return { KHR_shader_subgroup_ballot, NV_shader_thread_group };
case SubgroupAll_Any_AllEqualBool:
return { KHR_shader_subgroup_vote, NV_gpu_shader_5, ARB_shader_group_vote, AMD_gcn_shader };
case SubgroupAllEqualT:
return {}; // depends on other features only
case SubgroupElect:
return {}; // depends on other features only
case SubgroupBallot:
return { KHR_shader_subgroup_ballot, NV_shader_thread_group, ARB_shader_ballot };
case SubgroupBarrier:
return { KHR_shader_subgroup_basic, NV_shader_thread_group, ARB_shader_ballot, AMD_gcn_shader };
case SubgroupMemBarrier:
return { KHR_shader_subgroup_basic };
case SubgroupInverseBallot_InclBitCount_ExclBitCout:
return {};
case SubgroupBallotBitExtract:
return { NV_shader_thread_group };
case SubgroupBallotBitCount:
return {};
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
case SubgroupArithmeticIAddReduce:
case SubgroupArithmeticIAddExclusiveScan:
case SubgroupArithmeticIAddInclusiveScan:
GLSL: Support KHR_subgroup_arithmetic FAdd Support NV workarounds for FAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-02 07:45:25 +00:00
case SubgroupArithmeticFAddReduce:
case SubgroupArithmeticFAddExclusiveScan:
case SubgroupArithmeticFAddInclusiveScan:
GLSL: Support KHR_subgroup_arithmetic IMul/FMul Support NV workarounds for IMul/FMul Reduce/InclusiveScan/ExclusiveScan
2023-04-03 16:13:30 +00:00
case SubgroupArithmeticIMulReduce:
case SubgroupArithmeticIMulExclusiveScan:
case SubgroupArithmeticIMulInclusiveScan:
case SubgroupArithmeticFMulReduce:
case SubgroupArithmeticFMulExclusiveScan:
case SubgroupArithmeticFMulInclusiveScan:
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
return { KHR_shader_subgroup_arithmetic, NV_shader_thread_shuffle };
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
default:
return {};
}
}
Run format_all.sh.
2020-11-08 12:59:52 +00:00
CompilerGLSL::ShaderSubgroupSupportHelper::FeatureMask CompilerGLSL::ShaderSubgroupSupportHelper::build_mask(
const SmallVector<Feature> &features)
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
{
FeatureMask mask = 0;
for (Feature f : features)
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
mask |= FeatureMask(1) << f;
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
return mask;
}
CompilerGLSL::ShaderSubgroupSupportHelper::Result::Result()
{
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
for (auto &weight : weights)
weight = 0;
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
Style nits for GL subgroup implementation.
2020-10-08 10:41:01 +00:00
// Make sure KHR_shader_subgroup extensions are always prefered.
const uint32_t big_num = FeatureCount;
weights[KHR_shader_subgroup_ballot] = big_num;
weights[KHR_shader_subgroup_basic] = big_num;
weights[KHR_shader_subgroup_vote] = big_num;
GLSL: Support KHR_subgroup_arithmetic IAdd Support NV workarounds for IAdd Reduce/InclusiveScan/ExclusiveScan
2023-04-01 22:25:15 +00:00
weights[KHR_shader_subgroup_arithmetic] = big_num;
Resolved issues 1350, 1351, 1352
2020-10-08 10:14:52 +00:00
}
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
void CompilerGLSL::request_workaround_wrapper_overload(TypeID id)
{
// Must be ordered to maintain deterministic output, so vector is appropriate.
if (find(begin(workaround_ubo_load_overload_types), end(workaround_ubo_load_overload_types), id) ==
end(workaround_ubo_load_overload_types))
{
force_recompile();
workaround_ubo_load_overload_types.push_back(id);
}
}
void CompilerGLSL::rewrite_load_for_wrapped_row_major(std::string &expr, TypeID loaded_type, ID ptr)
{
// Loading row-major matrices from UBOs on older AMD Windows OpenGL drivers is problematic.
// To load these types correctly, we must first wrap them in a dummy function which only purpose is to
// ensure row_major decoration is actually respected.
auto *var = maybe_get_backing_variable(ptr);
if (!var)
return;
auto &backing_type = get<SPIRType>(var->basetype);
Run format_all.sh.
2020-11-08 12:59:52 +00:00
bool is_ubo = backing_type.basetype == SPIRType::Struct && backing_type.storage == StorageClassUniform &&
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
has_decoration(backing_type.self, DecorationBlock);
if (!is_ubo)
return;
auto *type = &get<SPIRType>(loaded_type);
bool rewrite = false;
GLSL: Fix row-major workaround wrapper for ES. By default, the matrix would be declared as mediump, causing precision issues. Need to dispatch to two separate functions since GLSL does not support overload based on precision.
2022-12-13 14:38:58 +00:00
bool relaxed = options.es;
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
if (is_matrix(*type))
{
// To avoid adding a lot of unnecessary meta tracking to forward the row_major state,
// we will simply look at the base struct itself. It is exceptionally rare to mix and match row-major/col-major state.
// If there is any row-major action going on, we apply the workaround.
// It is harmless to apply the workaround to column-major matrices, so this is still a valid solution.
// If an access chain occurred, the workaround is not required, so loading vectors or scalars don't need workaround.
type = &backing_type;
}
GLSL: Fix row-major workaround wrapper for ES. By default, the matrix would be declared as mediump, causing precision issues. Need to dispatch to two separate functions since GLSL does not support overload based on precision.
2022-12-13 14:38:58 +00:00
else
{
// If we're loading a composite, we don't have overloads like these.
relaxed = false;
}
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
if (type->basetype == SPIRType::Struct)
{
// If we're loading a struct where any member is a row-major matrix, apply the workaround.
for (uint32_t i = 0; i < uint32_t(type->member_types.size()); i++)
{
GLSL: Fix row-major workaround wrapper for ES. By default, the matrix would be declared as mediump, causing precision issues. Need to dispatch to two separate functions since GLSL does not support overload based on precision.
2022-12-13 14:38:58 +00:00
auto decorations = combined_decoration_for_member(*type, i);
if (decorations.get(DecorationRowMajor))
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
rewrite = true;
GLSL: Fix row-major workaround wrapper for ES. By default, the matrix would be declared as mediump, causing precision issues. Need to dispatch to two separate functions since GLSL does not support overload based on precision.
2022-12-13 14:38:58 +00:00
// Since we decide on a per-struct basis, only use mediump wrapper if all candidates are mediump.
if (!decorations.get(DecorationRelaxedPrecision))
relaxed = false;
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
}
}
if (rewrite)
{
request_workaround_wrapper_overload(loaded_type);
GLSL: Fix row-major workaround wrapper for ES. By default, the matrix would be declared as mediump, causing precision issues. Need to dispatch to two separate functions since GLSL does not support overload based on precision.
2022-12-13 14:38:58 +00:00
expr = join("spvWorkaroundRowMajor", (relaxed ? "MP" : ""), "(", expr, ")");
GLSL: Support a workaround for loading row-major matrices. On AMD Windows OpenGL, it has been reported that we need to load matrices via a wrapper function.
2020-10-14 13:51:49 +00:00
}
}
MSL: Sketch out API to aid LTO-style optimization.
2021-03-25 17:08:49 +00:00
void CompilerGLSL::mask_stage_output_by_location(uint32_t location, uint32_t component)
{
masked_output_locations.insert({ location, component });
}
void CompilerGLSL::mask_stage_output_by_builtin(BuiltIn builtin)
{
masked_output_builtins.insert(builtin);
}
MSL: Refactor out variable/block member masking.
2021-04-06 12:12:24 +00:00
bool CompilerGLSL::is_stage_output_variable_masked(const SPIRVariable &var) const
{
MSL: Fix masking of vertex block outputs.
2021-04-06 12:43:34 +00:00
auto &type = get<SPIRType>(var.basetype);
bool is_block = has_decoration(type.self, DecorationBlock);
MSL: Refactor out variable/block member masking.
2021-04-06 12:12:24 +00:00
// Blocks by themselves are never masked. Must be masked per-member.
if (is_block)
return false;
bool is_builtin = has_decoration(var.self, DecorationBuiltIn);
if (is_builtin)
{
return is_stage_output_builtin_masked(BuiltIn(get_decoration(var.self, DecorationBuiltIn)));
}
else
{
if (!has_decoration(var.self, DecorationLocation))
return false;
return is_stage_output_location_masked(
get_decoration(var.self, DecorationLocation),
get_decoration(var.self, DecorationComponent));
}
}
MSL: Fix masking of vertex block outputs.
2021-04-06 12:43:34 +00:00
bool CompilerGLSL::is_stage_output_block_member_masked(const SPIRVariable &var, uint32_t index, bool strip_array) const
MSL: Refactor out variable/block member masking.
2021-04-06 12:12:24 +00:00
{
MSL: Fix masking of vertex block outputs.
2021-04-06 12:43:34 +00:00
auto &type = get<SPIRType>(var.basetype);
MSL: Refactor out variable/block member masking.
2021-04-06 12:12:24 +00:00
bool is_block = has_decoration(type.self, DecorationBlock);
if (!is_block)
return false;
BuiltIn builtin = BuiltInMax;
if (is_member_builtin(type, index, &builtin))
{
return is_stage_output_builtin_masked(builtin);
}
else
{
MSL: Fix masking of vertex block outputs.
2021-04-06 12:43:34 +00:00
uint32_t location = get_declared_member_location(var, index, strip_array);
uint32_t component = get_member_decoration(type.self, index, DecorationComponent);
return is_stage_output_location_masked(location, component);
MSL: Refactor out variable/block member masking.
2021-04-06 12:12:24 +00:00
}
}
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
bool CompilerGLSL::is_per_primitive_variable(const SPIRVariable &var) const
{
if (has_decoration(var.self, DecorationPerPrimitiveEXT))
return true;
auto &type = get<SPIRType>(var.basetype);
if (!has_decoration(type.self, DecorationBlock))
return false;
HLSL: Fix-up some style issues from review.
2022-11-02 11:13:42 +00:00
for (uint32_t i = 0, n = uint32_t(type.member_types.size()); i < n; i++)
HLSL: Implement VK_EXT_mesh_shader
2022-10-10 22:16:45 +00:00
if (!has_member_decoration(type.self, i, DecorationPerPrimitiveEXT))
return false;
return true;
}
MSL: Sketch out API to aid LTO-style optimization.
2021-03-25 17:08:49 +00:00
bool CompilerGLSL::is_stage_output_location_masked(uint32_t location, uint32_t component) const
{
return masked_output_locations.count({ location, component }) != 0;
}
bool CompilerGLSL::is_stage_output_builtin_masked(spv::BuiltIn builtin) const
{
return masked_output_builtins.count(builtin) != 0;
MSL: Fix masking of vertex block outputs.
2021-04-06 12:43:34 +00:00
}
uint32_t CompilerGLSL::get_declared_member_location(const SPIRVariable &var, uint32_t mbr_idx, bool strip_array) const
{
auto &block_type = get<SPIRType>(var.basetype);
if (has_member_decoration(block_type.self, mbr_idx, DecorationLocation))
return get_member_decoration(block_type.self, mbr_idx, DecorationLocation);
else
return get_accumulated_member_location(var, mbr_idx, strip_array);
}
uint32_t CompilerGLSL::get_accumulated_member_location(const SPIRVariable &var, uint32_t mbr_idx, bool strip_array) const
{
auto &type = strip_array ? get_variable_element_type(var) : get_variable_data_type(var);
uint32_t location = get_decoration(var.self, DecorationLocation);
for (uint32_t i = 0; i < mbr_idx; i++)
{
auto &mbr_type = get<SPIRType>(type.member_types[i]);
// Start counting from any place we have a new location decoration.
if (has_member_decoration(type.self, mbr_idx, DecorationLocation))
location = get_member_decoration(type.self, mbr_idx, DecorationLocation);
HLSL: Fix automatic location assignment in block IO.
2021-04-20 11:03:58 +00:00
uint32_t location_count = type_to_location_count(mbr_type);
MSL: Fix masking of vertex block outputs.
2021-04-06 12:43:34 +00:00
location += location_count;
}
return location;
}
MSL: Fix copy of arrays to/from stage IO variables. Need to take into account effective storage classes and whether or not we target stage IO blocks since native arrays are conditionally enabled.
2021-04-19 09:46:30 +00:00
StorageClass CompilerGLSL::get_expression_effective_storage_class(uint32_t ptr)
{
auto *var = maybe_get_backing_variable(ptr);
// If the expression has been lowered to a temporary, we need to use the Generic storage class.
// We're looking for the effective storage class of a given expression.
// An access chain or forwarded OpLoads from such access chains
// will generally have the storage class of the underlying variable, but if the load was not forwarded
// we have lost any address space qualifiers.
bool forced_temporary = ir.ids[ptr].get_type() == TypeExpression && !get<SPIRExpression>(ptr).access_chain &&
(forced_temporaries.count(ptr) != 0 || forwarded_temporaries.count(ptr) == 0);
if (var && !forced_temporary)
{
if (variable_decl_is_remapped_storage(*var, StorageClassWorkgroup))
return StorageClassWorkgroup;
if (variable_decl_is_remapped_storage(*var, StorageClassStorageBuffer))
return StorageClassStorageBuffer;
// Normalize SSBOs to StorageBuffer here.
if (var->storage == StorageClassUniform &&
has_decoration(get<SPIRType>(var->basetype).self, DecorationBufferBlock))
return StorageClassStorageBuffer;
else
return var->storage;
}
else
return expression_type(ptr).storage;
}
HLSL: Fix automatic location assignment in block IO.
2021-04-20 11:03:58 +00:00
uint32_t CompilerGLSL::type_to_location_count(const SPIRType &type) const
{
uint32_t count;
if (type.basetype == SPIRType::Struct)
{
uint32_t mbr_count = uint32_t(type.member_types.size());
count = 0;
for (uint32_t i = 0; i < mbr_count; i++)
count += type_to_location_count(get<SPIRType>(type.member_types[i]));
}
else
{
count = type.columns > 1 ? type.columns : 1;
}
uint32_t dim_count = uint32_t(type.array.size());
for (uint32_t i = 0; i < dim_count; i++)
count *= to_array_size_literal(type, i);
return count;
}
Allow to customize float literals in output
2023-11-22 12:06:05 +00:00
std::string CompilerGLSL::format_float(float value) const
{
if (float_formatter)
return float_formatter->format_float(value);
// default behavior
return convert_to_string(value, current_locale_radix_character);
}
std::string CompilerGLSL::format_double(double value) const
{
if (float_formatter)
return float_formatter->format_double(value);
// default behavior
return convert_to_string(value, current_locale_radix_character);
}
Reference in New Issue Copy Permalink