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

10855 lines
329 KiB
C++
Raw Normal View History

Initial commit.
2016-03-02 17:09:16 +00:00
/*
Nonfunctional: Update copyright headers for 2019.
2019-01-04 11:38:35 +00:00
* Copyright 2015-2019 Arm Limited
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.
*/
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>
Fix bugs with row-major matrices inside flattened UBOs.
2017-01-21 12:49:32 +00:00
#include <utility>
Initial commit.
2016-03-02 17:09:16 +00:00
using namespace spv;
Rename project to SPIRV-Cross. Rename to coincide with moving the project to KhronosGroup.
2016-04-04 07:36:04 +00:00
using namespace spirv_cross;
Initial commit.
2016-03-02 17:09:16 +00:00
using namespace std;
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:
case BufferPackingHLSLCbuffer:
return false;
default:
return true;
}
}
static BufferPackingStandard packing_to_substruct_packing(BufferPackingStandard packing)
{
switch (packing)
{
case BufferPackingStd140EnhancedLayout:
return BufferPackingStd140;
case BufferPackingStd430EnhancedLayout:
return BufferPackingStd430;
case BufferPackingHLSLCbufferPackOffset:
return BufferPackingHLSLCbuffer;
default:
return packing;
}
}
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
// Sanitizes underscores for GLSL where multiple underscores in a row are not allowed.
Use packoffset in HLSL. Rewrite how cbuffers are emitted.
2017-10-10 11:15:49 +00:00
string CompilerGLSL::sanitize_underscores(const string &str)
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
{
string res;
res.reserve(str.size());
bool last_underscore = false;
for (auto c : str)
{
if (c == '_')
{
if (last_underscore)
continue;
res += c;
last_underscore = true;
}
else
{
res += c;
last_underscore = false;
}
}
return res;
}
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
// Returns true if an arithmetic operation does not change behavior depending on signedness.
Uniquely name these static functions
2018-02-03 22:23:30 +00:00
static bool glsl_opcode_is_sign_invariant(Op 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 (opcode)
{
case OpIEqual:
case OpINotEqual:
case OpISub:
case OpIAdd:
case OpIMul:
case OpShiftLeftLogical:
case OpBitwiseOr:
case OpBitwiseXor:
case OpBitwiseAnd:
return true;
default:
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
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
}
static SPIRType::BaseType pls_format_to_basetype(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 PlsR11FG11FB10F:
case PlsR32F:
case PlsRG16F:
case PlsRGB10A2:
case PlsRGBA8:
case PlsRG16:
return SPIRType::Float;
case PlsRGBA8I:
case PlsRG16I:
return SPIRType::Int;
case PlsRGB10A2UI:
case PlsRGBA8UI:
case PlsRG16UI:
case PlsR32UI:
return SPIRType::UInt;
}
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
}
Run style formatter.
2017-01-20 16:33:59 +00:00
static const char *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 style formatter.
2017-01-20 16:33:59 +00:00
static const char *swizzle[4][4] = {
{ ".x", ".y", ".z", ".w" }, { ".xy", ".yz", ".zw" }, { ".xyz", ".yzw" }, { "" }
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];
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::reset()
{
Add Clang format. Reformats the entire codebase. Better to do it now 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.
force_recompile = false;
// Clear invalid expression tracking.
invalid_expressions.clear();
current_function = nullptr;
// Clear temporary usage tracking.
expression_usage_counts.clear();
forwarded_temporaries.clear();
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
resource_names.clear();
GLSL: Allow blocks to have their own namespace.
2018-08-21 09:29:08 +00:00
block_input_names.clear();
block_output_names.clear();
block_ubo_names.clear();
block_ssbo_names.clear();
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.clear();
Handle overloaded functions which share the same OpName. Awkward, but legal SPIR-V.
2018-02-23 13:13:46 +00:00
function_overloads.clear();
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
ir.reset_all_of_type<SPIRExpression>();
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;
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
}
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");
}
Add support for int64/uint64 in GLSL.
2016-07-27 09:27: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 (type.basetype == SPIRType::Int64 || type.basetype == SPIRType::UInt64)
{
if (options.es)
SPIRV_CROSS_THROW("64-bit integers not supported in ES profile.");
if (!options.es)
require_extension_internal("GL_ARB_gpu_shader_int64");
}
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +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 (type.basetype == SPIRType::Half)
require_extension_internal("GL_AMD_gpu_shader_half_float");
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
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 (type.basetype == SPIRType::SByte || type.basetype == SPIRType::UByte)
require_extension_internal("GL_EXT_shader_8bit_storage");
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +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 (type.basetype == SPIRType::Short || type.basetype == SPIRType::UShort)
require_extension_internal("GL_AMD_gpu_shader_int16");
});
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;
default:
break;
}
if (!pls_inputs.empty() || !pls_outputs.empty())
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");
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");
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
}
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::compile()
{
Use the classic locale when converting floats to string
2017-01-11 14:57:05 +00:00
// Force a classic "C" locale, reverts when function returns
ClassicLocale classic_locale;
Support mediump in desktop Vulkan GLSL.
2017-12-06 09:25:30 +00:00
if (options.vulkan_semantics)
backend.allow_precision_qualifiers = true;
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;
Support mediump in desktop Vulkan GLSL.
2017-12-06 09:25:30 +00:00
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
// Scan the SPIR-V to find trivial uses of extensions.
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();
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
uint32_t pass_count = 0;
do
{
if (pass_count >= 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("Over 3 compilation loops detected. Must be a bug!");
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
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
// Move constructor for this type is broken on GCC 4.9 ...
buffer = unique_ptr<ostringstream>(new ostringstream());
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();
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
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++;
} while (force_recompile);
Initial commit.
2016-03-02 17:09:16 +00:00
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";
Add Clang format. Reformats the entire codebase. Better to do it now 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 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()
{
CompilerMSL enhancements. Support BuiltInFragDepth. Emit interface block for StorageClassUniformConstant. Throw exception when output or fragment input structs contain matrix or array. Dynamically created interface structs sorted by location number instead of alphabetically. Add Compiler::is_array() function.
2017-06-30 23:10:46 +00:00
return buffer ? buffer->str() : "No compiled source available yet.";
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
}
Run format_all.sh.
2018-11-01 10:23:33 +00:00
void CompilerGLSL::build_workgroup_size(vector<string> &arguments, const SpecializationConstant &wg_x,
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();
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));
}
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));
}
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));
}
else
arguments.push_back(join("local_size_z = ", execution.workgroup_size.z));
}
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
}
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
{
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 (ext == "GL_AMD_gpu_shader_half_float")
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");
}
statement("#elif defined(GL_EXT_shader_16bit_storage)");
statement("#extension GL_EXT_shader_16bit_storage : 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");
}
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
else if (ext == "GL_AMD_gpu_shader_int16")
{
// GL_AMD_gpu_shader_int16 is a superset, so try that first.
statement("#if defined(GL_AMD_gpu_shader_int16)");
statement("#extension GL_AMD_gpu_shader_int16 : require");
statement("#elif defined(GL_EXT_shader_16bit_storage)");
statement("#extension GL_EXT_shader_16bit_storage : require");
statement("#else");
statement("#error No extension available for Int16.");
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
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
vector<string> inputs;
vector<string> outputs;
switch (execution.model)
{
case ExecutionModelGeometry:
outputs.push_back(join("max_vertices = ", execution.output_vertices));
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");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeOutputTriangleStrip))
Add Clang format. Reformats the entire codebase. Better to do it now 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("triangle_strip");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeOutputPoints))
Add Clang format. Reformats the entire codebase. Better to do it now 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("points");
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (execution.flags.get(ExecutionModeOutputLineStrip))
Add Clang format. Reformats the entire codebase. Better to do it now 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("line_strip");
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:
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
{
if (execution.workgroup_size.constant != 0)
{
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.
if (options.vulkan_semantics || ((wg_x.id == 0) && (wg_y.id == 0) && (wg_z.id == 0)))
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));
}
Add Clang format. Reformats the entire codebase. Better to do it now 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");
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;
}
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 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
if (type.type_alias != 0 && !has_extended_decoration(type.type_alias, SPIRVCrossDecorationPacked))
Add Clang format. Reformats the entire codebase. Better to do it now 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;
}
Add Clang format. Reformats the entire codebase. Better to do it now 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))
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += "noperspective ";
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))
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += "sample ";
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationInvariant))
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
res += "invariant ";
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationExplicitInterpAMD))
Update tests for latest SPIRV-Tools and glslang.
2018-03-12 13:58:40 +00:00
res += "__explicitInterpAMD ";
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 "";
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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];
vector<string> attr;
// 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.
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
if (has_extended_decoration(type.self, SPIRVCrossDecorationPacked) && 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));
Add Clang format. Reformats the entire codebase. Better to do it now 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";
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
{
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
if (!type.array.empty())
{
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))
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
alignment = max(alignment, 16u);
Add Clang format. Reformats the entire codebase. Better to do it now 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);
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);
if (tmp.array.empty())
{
uint32_t alignment = type_to_packed_alignment(type, flags, packing);
return (size + alignment - 1) & ~(alignment - 1);
}
else
{
// For multidimensional arrays, array stride always matches size of subtype.
// The alignment cannot change because multidimensional arrays are basically N * M array elements.
return size;
}
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
{
Add Clang format. Reformats the entire codebase. Better to do it now 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.array.empty())
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
return to_array_size_literal(type) * type_to_packed_array_stride(type, flags, packing);
Add more robust HLSL packing support.
2017-10-10 13:23:07 +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);
Add Clang format. Reformats the entire codebase. Better to do it now 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.columns == 1)
size = type.vecsize * base_alignment;
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))
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
size = type.columns * 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
size = type.columns * 4 * base_alignment;
else
size = type.columns * type.vecsize * base_alignment;
}
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))
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
size = type.vecsize * 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
size = type.vecsize * 4 * base_alignment;
else
size = type.vecsize * type.columns * base_alignment;
}
}
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,
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]);
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
// 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;
if (!member_can_be_unsized)
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.
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.
uint32_t begin_word = offset / 16;
uint32_t end_word = (offset + packed_size - 1) / 16;
if (begin_word != end_word)
packed_alignment = max(packed_alignment, 16u);
}
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
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
offset = (offset + alignment - 1) & ~(alignment - 1);
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.
if (offset >= end_offset)
break;
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 (memb_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
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
if (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))
{
uint32_t actual_offset = type_struct_member_offset(type, i);
if (actual_offset != offset) // This cannot be the packing we're looking for.
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.
if (!memb_type.array.empty() && type_to_packed_array_stride(memb_type, member_flags, packing) !=
type_struct_member_array_stride(type, i))
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 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
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
if (!memb_type.member_types.empty() && !buffer_is_packing_standard(memb_type, substruct_packing))
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
// Bump size.
Add more robust HLSL packing support.
2017-10-10 13:23:07 +00:00
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
}
Strip uniform locations for ESSL < 3.00 and GLSL < 430
2018-04-07 19:14:35 +00:00
if (storage == StorageClassUniform || storage == StorageClassUniformConstant)
{
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 "";
Add Clang format. Reformats the entire codebase. Better to do it now 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<string> attr;
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
auto &type = get<SPIRType>(var.basetype);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = dec.decoration_flags;
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 typeflags = ir.meta[type.self].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
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");
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))
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
attr.push_back(join("input_attachment_index = ", dec.input_attachment));
}
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))
Also check IO location for blocks.
2017-10-19 12:17:18 +00:00
attr.push_back(join("location = ", dec.location));
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
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))
{
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.");
}
Support dual-source blending on GLSL and MSL.
2018-04-03 13:56:22 +00:00
if (flags.get(DecorationIndex))
attr.push_back(join("index = ", dec.index));
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.
Always emit DescriptorSet decoration for Vulkan GLSL.
2016-05-05 09:51:18 +00:00
if (var.storage != StorageClassPushConstant)
{
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)
Always emit DescriptorSet decoration for Vulkan GLSL.
2016-05-05 09:51:18 +00:00
attr.push_back(join("set = ", dec.set));
}
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);
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;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (can_use_binding && flags.get(DecorationBinding))
Add Clang format. Reformats the entire codebase. Better to do it now 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("binding = ", dec.binding));
Add option to disable use of 420pack extension.
2017-09-08 07:56:06 +00:00
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(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
attr.push_back(join("offset = ", dec.offset));
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
bool push_constant_block = options.vulkan_semantics && var.storage == StorageClassPushConstant;
bool ssbo_block = var.storage == StorageClassStorageBuffer ||
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
(var.storage == StorageClassUniform && typeflags.get(DecorationBufferBlock));
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
// 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.
Emit classic uniform for UBO in GLSL 1.30.
2018-04-03 14:46:58 +00:00
if (can_use_buffer_blocks && var.storage == StorageClassUniform && typeflags.get(DecorationBlock))
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
{
Update HLSL cbuffer tests.
2017-10-10 13:37:53 +00:00
if (buffer_is_packing_standard(type, BufferPackingStd140))
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
attr.push_back("std140");
Update HLSL cbuffer tests.
2017-10-10 13:37:53 +00:00
else if (buffer_is_packing_standard(type, BufferPackingStd140EnhancedLayout))
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
{
Add a test for enhanced layouts.
2017-10-10 09:30:29 +00:00
attr.push_back("std140");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +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.
if (options.es && !options.vulkan_semantics)
Run format_all.sh.
2017-10-10 09:31:05 +00:00
SPIRV_CROSS_THROW("Push constant block cannot be expressed as neither std430 nor std140. ES-targets do "
"not support GL_ARB_enhanced_layouts.");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
if (!options.es && !options.vulkan_semantics && options.version < 440)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_enhanced_layouts");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
// This is a very last minute to check for this, but use this unused decoration to mark that we should emit
// explicit offsets for this block type.
// layout_for_variable() will be called before the actual buffer emit.
// The alternative is a full pass before codegen where we deduce this decoration,
// but then we are just doing the exact same work twice, and more complexity.
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
set_extended_decoration(type.self, SPIRVCrossDecorationPacked);
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
}
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
else
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
{
Run format_all.sh.
2017-10-10 09:31:05 +00:00
SPIRV_CROSS_THROW("Uniform buffer cannot be expressed as std140, even with enhanced layouts. You can try "
"flattening this block to "
"support a more flexible layout.");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
}
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
{
Update HLSL cbuffer tests.
2017-10-10 13:37:53 +00:00
if (buffer_is_packing_standard(type, BufferPackingStd430))
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
attr.push_back("std430");
Update HLSL cbuffer tests.
2017-10-10 13:37:53 +00:00
else if (buffer_is_packing_standard(type, BufferPackingStd140))
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
attr.push_back("std140");
Update HLSL cbuffer tests.
2017-10-10 13:37:53 +00:00
else if (buffer_is_packing_standard(type, BufferPackingStd140EnhancedLayout))
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
{
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
attr.push_back("std140");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +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.
if (options.es && !options.vulkan_semantics)
Run format_all.sh.
2017-10-10 09:31:05 +00:00
SPIRV_CROSS_THROW("Push constant block cannot be expressed as neither std430 nor std140. ES-targets do "
"not support GL_ARB_enhanced_layouts.");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
if (!options.es && !options.vulkan_semantics && options.version < 440)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_enhanced_layouts");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
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
set_extended_decoration(type.self, SPIRVCrossDecorationPacked);
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
}
Update HLSL cbuffer tests.
2017-10-10 13:37:53 +00:00
else if (buffer_is_packing_standard(type, BufferPackingStd430EnhancedLayout))
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
{
attr.push_back("std430");
if (options.es && !options.vulkan_semantics)
Run format_all.sh.
2017-10-10 09:31:05 +00:00
SPIRV_CROSS_THROW("Push constant block cannot be expressed as neither std430 nor std140. ES-targets do "
"not support GL_ARB_enhanced_layouts.");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
if (!options.es && !options.vulkan_semantics && options.version < 440)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_ARB_enhanced_layouts");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
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
set_extended_decoration(type.self, SPIRVCrossDecorationPacked);
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
}
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
else
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
{
Run format_all.sh.
2017-10-10 09:31:05 +00:00
SPIRV_CROSS_THROW("Buffer block cannot be expressed as neither std430 nor std140, even with enhanced "
"layouts. You can try flattening this block to support a more flexible layout.");
Add support for GL_ARB_enhanced_layouts.
2017-10-10 09:05:46 +00:00
}
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
}
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);
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
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.meta[var.self].decoration.decoration_flags;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
flags.clear(DecorationBinding);
flags.clear(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.
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);
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)
block_flags.set(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
{
if (flattened_buffer_blocks.count(var.self))
emit_buffer_block_flattened(var);
Emit classic uniform for UBO in GLSL 1.30.
2018-04-03 14:46:58 +00:00
else if (is_legacy() || (!options.es && options.version == 130))
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("");
}
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);
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);
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++;
}
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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(to_name(var.self) + type_to_array_glsl(type));
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))
{
SPIRType tmp;
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);
Comment type ID a bit better.
2017-01-22 08:06:15 +00:00
statement("uniform ", flags_to_precision_qualifiers_glsl(tmp, flags), type_to_glsl(tmp), " ", buffer_name, "[",
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
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.
else
return var.storage == StorageClassInput ? "in " : "out ";
}
else if (var.storage == StorageClassUniformConstant || var.storage == StorageClassUniform ||
var.storage == StorageClassPushConstant)
{
return "uniform ";
}
return "";
}
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
{
Add Clang format. Reformats the entire codebase. Better to do it now 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);
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 (!type.array.empty())
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
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();
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
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)
SPIRV_CROSS_THROW("Cannot flatten struct inside structs in I/O variables.");
// 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.
// Sanitize underscores because joining the two identifiers might create more than 1 underscore in a row,
// which is not allowed.
Fix some naming issues for stripped and flattened structs.
2017-10-10 15:32:26 +00:00
auto backup_name = get_member_name(type.self, i);
auto member_name = to_member_name(type, i);
Flatten structs based on instance name rather than block name. Block name is too brittle, optimizes will merge block types, making flattening impossible with unique names.
2018-01-09 09:36:04 +00:00
set_member_name(type.self, i, sanitize_underscores(join(to_name(var.self), "_", member_name)));
Updates to MSL functionality to support PR review feedback.
2017-03-11 17:17:22 +00:00
emit_struct_member(type, member, i, qual);
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
// Restore member name.
set_member_name(type.self, i, member_name);
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
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
// Treat this variable as flattened from now on.
flattened_structs.insert(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
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
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.
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 ((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
}
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
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(layout_for_variable(var), qual, block_name);
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);
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
end_scope_decl(join(to_name(var.self), type_to_array_glsl(type)));
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 &&
((options.es && options.version < 310) || (!options.es && options.version < 150)))
{
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);
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),
variable_decl(type, to_name(var.self), var.self), ";");
Support initializers on StorageClassOutput.
2019-01-30 09:29:08 +00:00
// If a StorageClassOutput variable has an initializer, we need to initialize it in main().
if (var.storage == StorageClassOutput && var.initializer)
{
auto &entry_func = this->get<SPIRFunction>(ir.default_entry_point);
entry_func.fixup_hooks_in.push_back([&]() {
statement(to_name(var.self), " = ", to_expression(var.initializer), ";");
});
}
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);
Only check for image load/store if sampling type is 2. uniform texture2D is sampling type 1.
2016-09-10 11:00:07 +00:00
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
{
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);
auto name = to_name(constant.self);
statement("const ", variable_decl(type, name), " = ", constant_op_expression(constant), ";");
}
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);
auto name = to_name(constant.self);
Implement specialization constants for work group sizes.
2017-09-28 09:33:30 +00:00
SpecializationConstant wg_x, wg_y, wg_z;
uint32_t workgroup_size_id = 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
// 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.
Run format_all.sh.
2018-11-01 10:23:33 +00:00
bool is_workgroup_size_constant = constant.self == wg_x.id || constant.self == wg_y.id || 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;
}
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()
{
}
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
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, const SPIRVariable &var) {
if (!is_hidden_variable(var))
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
{
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
auto &m = ir.meta[var.self].decoration;
if (m.alias.compare(0, 3, "gl_") == 0 || keywords.find(m.alias) != end(keywords))
m.alias = join("_", m.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
}
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
});
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()
{
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);
if (vartype.basetype == SPIRType::Image)
{
// Older glslangValidator does not emit required qualifiers here.
// 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.
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 &flags = ir.meta[var].decoration.decoration_flags;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (!flags.get(DecorationNonWritable) && !flags.get(DecorationNonReadable))
{
flags.set(DecorationNonWritable);
flags.set(DecorationNonReadable);
}
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
}
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
bool builtin_array = false;
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;
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
{
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
if (m.builtin)
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)
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
cull_distance_size = this->get<SPIRType>(type.member_types[index]).array.front();
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
else if (m.builtin_type == BuiltInClipDistance)
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
clip_distance_size = this->get<SPIRType>(type.member_types[index]).array.front();
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
}
index++;
}
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;
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
if (m.builtin)
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
global_builtins.set(m.builtin_type);
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
if (m.builtin_type == BuiltInCullDistance)
cull_distance_size = type.array.front();
else if (m.builtin_type == BuiltInClipDistance)
clip_distance_size = type.array.front();
}
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;
builtin_array = !type.array.empty();
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)
statement("out gl_PerVertex");
else
statement("in gl_PerVertex");
begin_scope();
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
if (emitted_builtins.get(BuiltInPosition))
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
statement("vec4 gl_Position;");
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
if (emitted_builtins.get(BuiltInPointSize))
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
statement("float gl_PointSize;");
Refactor block IO emission to use bitset.
2018-03-12 14:59:34 +00:00
if (emitted_builtins.get(BuiltInClipDistance))
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
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))
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
statement("float gl_CullDistance[", cull_distance_size, "];");
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
bool tessellation = model == ExecutionModelTessellationEvaluation || model == ExecutionModelTessellationControl;
if (builtin_array)
{
// Make sure the array has a supported name in the code.
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
if (storage == StorageClassOutput)
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
set_name(block_var->self, "gl_out");
else if (storage == StorageClassInput)
set_name(block_var->self, "gl_in");
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
if (model == ExecutionModelTessellationControl && storage == StorageClassOutput)
end_scope_decl(join(to_name(block_var->self), "[", 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
Fix SSO for HLSL vertex shaders.
2017-11-17 12:37:28 +00:00
end_scope_decl(join(to_name(block_var->self), tessellation ? "[gl_MaxPatchVertices]" : "[]"));
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
}
Declare undefined values up front. They might potentially be used as part of OpStore in the SPIRV-Tools inliner in some cases. Implement these as declared variables but without any initializer.
2017-08-02 08:33:03 +00:00
void CompilerGLSL::declare_undefined_values()
{
bool 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
ir.for_each_typed_id<SPIRUndef>([&](uint32_t, const SPIRUndef &undef) {
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
statement(variable_decl(this->get<SPIRType>(undef.basetype), to_name(undef.self), undef.self), ";");
Declare undefined values up front. They might potentially be used as part of OpStore in the SPIRV-Tools inliner in some cases. Implement these as declared variables but without any initializer.
2017-08-02 08:33:03 +00:00
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
});
Declare undefined values up front. They might potentially be used as part of OpStore in the SPIRV-Tools inliner in some cases. Implement these as declared variables but without any initializer.
2017-08-02 08:33:03 +00:00
if (emitted)
statement("");
}
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();
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);
break;
case ExecutionModelVertex:
emit_declared_builtin_block(StorageClassOutput, execution.model);
break;
default:
break;
}
}
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
Support Invariant for BuiltInPosition.
2018-03-01 11:30:55 +00:00
if (position_invariant)
{
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.
//
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 (auto &id_ : ir.ids_for_constant_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
{
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
auto &id = ir.ids[id_];
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
if (id.get_type() == TypeConstant)
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
{
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
auto &c = id.get<SPIRConstant>();
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
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
bool needs_declaration = c.specialization || c.is_used_as_lut;
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
if (needs_declaration)
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
{
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
if (!options.vulkan_semantics && c.specialization)
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 macro overrides for spec constants in HLSL.
2018-11-01 09:53:00 +00:00
c.specialization_constant_macro_name =
Run format_all.sh.
2018-11-01 10:23:33 +00:00
constant_value_macro_name(get_decoration(c.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
}
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
emit_constant(c);
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;
}
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
}
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 (id.get_type() == TypeConstantOp)
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
{
emit_specialization_constant_op(id.get<SPIRConstantOp>());
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
else if (id.get_type() == TypeType)
{
auto &type = id.get<SPIRType>();
if (type.basetype == SPIRType::Struct && type.array.empty() && !type.pointer &&
(!ir.meta[type.self].decoration.decoration_flags.get(DecorationBlock) &&
!ir.meta[type.self].decoration.decoration_flags.get(DecorationBufferBlock)))
{
if (emitted)
statement("");
emitted = false;
emit_struct(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
}
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 &&
execution.workgroup_size.constant != 0)
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);
if ((wg_x.id != 0) || (wg_y.id != 0) || (wg_z.id != 0))
{
vector<string> inputs;
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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
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 is_block_storage = type.storage == StorageClassStorageBuffer || type.storage == StorageClassUniform;
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 &&
(type.storage == StorageClassUniformConstant || type.storage == StorageClassAtomicCounter) &&
!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;
// 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
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) &&
interface_variable_exists_in_entry_point(var.self) && !is_hidden_variable(var))
{
emit_interface_block(var);
emitted = true;
}
else if (is_builtin_variable(var))
{
// For gl_InstanceIndex emulation on GLES, the API user needs to
// supply this uniform.
if (options.vertex.support_nonzero_base_instance &&
ir.meta[var.self].decoration.builtin_type == BuiltInInstanceIndex && !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
{
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
statement("uniform int SPIRV_Cross_BaseInstance;");
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
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
});
Add Clang format. Reformats the entire codebase. Better to do it now 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);
if (var.storage != StorageClassOutput)
{
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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(variable_decl(var), ";");
emitted = true;
}
}
if (emitted)
statement("");
Declare undefined values up front. They might potentially be used as part of OpStore in the SPIRV-Tools inliner in some cases. Implement these as declared variables but without any initializer.
2017-08-02 08:33:03 +00:00
declare_undefined_values();
Initial commit.
2016-03-02 17:09:16 +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.
string CompilerGLSL::to_func_call_arg(uint32_t 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
// 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
}
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
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.
forced_temporaries.insert(id);
force_recompile = true;
}
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.
// Subclasses that do will override
Need to know the original packed type when unpacking loads.
2019-01-17 10:39:16 +00:00
string CompilerGLSL::unpack_expression_type(string expr_str, const SPIRType &, uint32_t)
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));
}
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
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
{
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
}
// 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.
if (need_parens)
return join('(', expr, ')');
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::dereference_expression(const std::string &expr)
{
// 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);
else
return join('*', expr);
}
string CompilerGLSL::address_of_expression(const std::string &expr)
{
// If this expression starts with a dereference 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);
else
return join('&', expr);
}
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
}
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;
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
if (!need_transpose && has_extended_decoration(id, SPIRVCrossDecorationPacked))
Need to know the original packed type when unpacking loads.
2019-01-17 10:39:16 +00:00
return unpack_expression_type(to_expression(id, register_expression_read), expression_type(id),
get_extended_decoration(id, SPIRVCrossDecorationPackedType));
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
{
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;
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
if (!need_transpose && has_extended_decoration(id, SPIRVCrossDecorationPacked))
Need to know the original packed type when unpacking loads.
2019-01-17 10:39:16 +00:00
return unpack_expression_type(to_expression(id, register_expression_read), expression_type(id),
get_extended_decoration(id, SPIRVCrossDecorationPackedType));
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_enclosed_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);
if (type.pointer && should_dereference(id))
return dereference_expression(to_enclosed_expression(id, register_expression_read));
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);
if (type.pointer && 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);
if (type.pointer && 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);
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
if (has_extended_decoration(id, SPIRVCrossDecorationPacked))
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));
}
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;
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 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
{
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
bool is_packed = has_extended_decoration(id, SPIRVCrossDecorationPacked);
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
return convert_row_major_matrix(e.expression, get<SPIRType>(e.expression_type), is_packed);
}
Add Clang format. Reformats the entire codebase. Better to do it now 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
{
if (force_recompile)
{
// 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.
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[c.self].decoration;
Correctly resolve constant expressions for WorkGroupSize.
2017-09-28 10:34:48 +00:00
if (dec.builtin)
return builtin_to_glsl(dec.builtin_type, 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)
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);
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))
Add Clang format. Reformats the entire codebase. Better to do it now 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 to_expression(var.static_expression);
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))
{
return load_flattened_struct(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
{
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
}
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
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];
if (index >= left_components)
expr += right_arg + "." + "xyzw"[index - left_components];
else
expr += left_arg + "." + "xyzw"[index];
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:
SPIRV_CROSS_THROW("OpCompositeInsert spec constant op is not supported.");
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
SPIRType::BaseType input_type;
Uniquely name these static functions
2018-02-03 22:23:30 +00:00
bool skip_cast_if_equal_type = glsl_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:
input_type = SPIRType::Int;
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]), ")");
}
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]), ")");
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::constant_expression(const SPIRConstant &c)
{
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
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 (type.pointer)
{
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;
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 &&
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
type.array.empty())
{
res = type_to_glsl_constructor(type) + "{ ";
}
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
Add Clang format. Reformats the entire codebase. Better to do it now 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)
{
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 &subc = get<SPIRConstant>(elem);
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 (subc.specialization)
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
res += to_name(elem);
else
Support OpConstantNull.
2017-08-03 12:32:07 +00:00
res += constant_expression(subc);
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 += ", ";
}
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 ? " }" : ")";
Add Clang format. Reformats the entire codebase. Better to do it now 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;
}
else if (c.columns() == 1)
{
return constant_expression_vector(c, 0);
}
else
{
string res = type_to_glsl(get<SPIRType>(c.constant_type)) + "(";
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 += ")";
return res;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
#ifdef _MSC_VER
// sprintf warning.
// We cannot rely on snprintf existing because, ..., MSVC.
#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);
if (std::isnan(float_value) || std::isinf(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
if (backend.half_literal_suffix)
{
// There is no uintBitsToFloat for 16-bit, so have to rely on legacy fallback here.
if (float_value == numeric_limits<float>::infinity())
res = join("(1.0", backend.half_literal_suffix, " / 0.0", backend.half_literal_suffix, ")");
else if (float_value == -numeric_limits<float>::infinity())
res = join("(-1.0", backend.half_literal_suffix, " / 0.0", backend.half_literal_suffix, ")");
else if (std::isnan(float_value))
res = join("(0.0", backend.half_literal_suffix, " / 0.0", backend.half_literal_suffix, ")");
else
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
{
SPIRType type;
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)");
else
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
{
if (backend.half_literal_suffix)
res = convert_to_string(float_value) + backend.half_literal_suffix;
else
{
// In HLSL (FXC), it's important to cast the literals to half precision right away.
// There is no literal for it.
SPIRType type;
type.basetype = SPIRType::Half;
type.vecsize = 1;
type.columns = 1;
res = join(type_to_glsl(type), "(", convert_to_string(float_value), ")");
}
}
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())
{
SPIRType out_type;
SPIRType in_type;
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];
sprintf(print_buffer, "0x%xu", c.scalar(col, row));
res = join(bitcast_glsl_op(out_type, in_type), "(", print_buffer, ")");
}
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
{
res = convert_to_string(float_value);
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())
{
SPIRType out_type;
SPIRType in_type;
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);
if (options.es)
SPIRV_CROSS_THROW("64-bit integers/float not supported in ES profile.");
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];
sprintf(print_buffer, "0x%llx%s", static_cast<unsigned long long>(u64_value),
backend.long_long_literal_suffix ? "ull" : "ul");
res = join(bitcast_glsl_op(out_type, in_type), "(", print_buffer, ")");
}
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
{
res = convert_to_string(double_value);
if (backend.double_literal_suffix)
res += "lf";
}
return res;
}
#ifdef _MSC_VER
#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;
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)
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
res += to_name(c.specialization_constant_id(vector, i));
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)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
res += to_name(c.specialization_constant_id(vector, i));
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)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
res += to_name(c.specialization_constant_id(vector, i));
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:
if (splat)
{
res += convert_to_string(c.scalar_i64(vector, 0));
if (backend.long_long_literal_suffix)
res += "ll";
else
res += "l";
}
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)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
res += to_name(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_i64(vector, i));
if (backend.long_long_literal_suffix)
res += "ll";
else
res += "l";
}
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
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)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
res += to_name(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)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
res += to_name(c.specialization_constant_id(vector, i));
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)
Run format_all.sh.
2018-04-17 13:01:31 +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)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
res += to_name(c.specialization_constant_id(vector, i));
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));
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_i16(vector, 0) < 0)
SPIRV_CROSS_THROW("Tried to convert uint literal into int, but this made the literal negative.");
}
else if (backend.uint16_t_literal_suffix)
res += backend.uint16_t_literal_suffix;
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
res += to_name(c.specialization_constant_id(vector, i));
else
{
res += convert_to_string(c.scalar(vector, i));
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_i16(vector, i) < 0)
SPIRV_CROSS_THROW(
"Tried to convert uint literal into int, but this made the literal negative.");
}
else if (backend.uint16_t_literal_suffix)
res += backend.uint16_t_literal_suffix;
}
if (i + 1 < c.vector_size())
res += ", ";
}
}
break;
case SPIRType::Short:
if (splat)
{
res += convert_to_string(c.scalar_i16(vector, 0));
if (backend.int16_t_literal_suffix)
res += backend.int16_t_literal_suffix;
}
else
{
for (uint32_t i = 0; i < c.vector_size(); i++)
{
if (c.vector_size() > 1 && c.specialization_constant_id(vector, i) != 0)
res += to_name(c.specialization_constant_id(vector, i));
else
{
res += convert_to_string(c.scalar_i16(vector, i));
if (backend.int16_t_literal_suffix)
res += backend.int16_t_literal_suffix;
}
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)
Support mixed constant composites.
2017-09-27 14:10:29 +00:00
res += to_name(c.specialization_constant_id(vector, i));
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
}
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);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = ir.meta[result_id].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
// 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.
Hoist all phi-local variables to entry block. We don't have a mechanism to move temporaries to their appropriate scope, and Phi behavior is weird enough that it will be a heroic effort to not do this rather ugly codegen :(
2017-11-21 17:19:51 +00:00
if (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);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
force_recompile = true;
}
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);
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
return join(flags_to_precision_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
}
bool CompilerGLSL::expression_is_forwarded(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
return forwarded_temporaries.find(id) != end(forwarded_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
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.
if (!suppress_usage_tracking)
forwarded_temporaries.insert(result_id);
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
}
void CompilerGLSL::emit_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, 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) && should_forward(op1);
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,
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.
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(op0, i);
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
expr += ' ';
expr += op;
expr += ' ';
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(op1, i);
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.
SPIRType expected_type;
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;
}
void CompilerGLSL::emit_binary_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);
// 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.
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(cast_op0, " ", op, " ", cast_op1);
expr += ')';
}
else
expr += join(cast_op0, " ", op, " ", 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
}
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
{
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);
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
}
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
}
Put check for lod legality in its own function Also add requested code style changes.
2017-03-23 12:25:24 +00:00
// EXT_shader_texture_lod only concerns fragment shaders so lod tex functions
// are not allowed in ES 2 vertex shaders. But SPIR-V only supports lod tex
// functions in vertex shaders so we revert those back to plain calls when
// the lod is a constant value of zero.
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
bool CompilerGLSL::check_explicit_lod_allowed(uint32_t lod)
Put check for lod legality in its own function Also add requested code style changes.
2017-03-23 12:25:24 +00:00
{
auto &execution = get_entry_point();
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
bool allowed = !is_legacy_es() || execution.model == ExecutionModelFragment;
Check for legal lod id And avoid passing superfluous has_lod parameter.
2017-03-24 08:26:02 +00:00
if (!allowed && lod != 0)
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
{
auto *lod_constant = maybe_get<SPIRConstant>(lod);
if (!lod_constant || lod_constant->scalar_f32() != 0.0f)
{
SPIRV_CROSS_THROW("Explicit lod not allowed in legacy ES non-fragment shaders.");
}
}
return allowed;
Put check for lod legality in its own function Also add requested code style changes.
2017-03-23 12:25:24 +00:00
}
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
string CompilerGLSL::legacy_tex_op(const std::string &op, const SPIRType &imgtype, uint32_t lod, 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:
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) ? "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;
}
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
bool use_explicit_lod = check_explicit_lod_allowed(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
Fixed emission of some legacy texture ops without requiring the appropriate extensions
2018-06-25 09:11:46 +00:00
if (op == "textureLod" || op == "textureProjLod" || op == "textureGrad" || op == "textureProjGrad")
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())
{
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
if (use_explicit_lod)
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_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
}
else if (is_legacy())
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
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 (image_is_comparison(imgtype, tex) && 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"));
}
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
bool is_es_and_depth = is_legacy_es() && image_is_comparison(imgtype, tex);
std::string type_prefix = image_is_comparison(imgtype, tex) ? "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")
{
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
if (use_explicit_lod)
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() ? "LodEXT" : "Lod");
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
else
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);
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
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")
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
{
if (use_explicit_lod)
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() ? "ProjLodEXT" : "ProjLod");
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
else
Added better fallbacks for legacy textureProjLod() and textureProjLodOffset() generation
2018-06-25 09:06:45 +00:00
return join(type_prefix, type, "Proj");
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
}
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")
Added support for shadowXY() sample instructions in legacy GLSL
2018-06-22 07:28:40 +00:00
{
if (use_explicit_lod)
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, "LodOffset");
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
else
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);
Added support for shadowXY() sample instructions in legacy GLSL
2018-06-22 07:28:40 +00:00
}
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")
Added support for shadowXY() sample instructions in legacy GLSL
2018-06-22 07:28:40 +00:00
{
if (use_explicit_lod)
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, "ProjLodOffset");
Added support for shadowXY() sample instructions in legacy GLSL
2018-06-22 07:28:40 +00:00
else
Added better fallbacks for legacy textureProjLod() and textureProjLodOffset() generation
2018-06-25 09:06:45 +00:00
return join(type_prefix, type, "ProjOffset");
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43: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
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;
// We can only use trivial construction if we have a scalar
// (should be possible to do it for vectors as well, but that is overkill for now).
if (lerptype.basetype != SPIRType::Boolean || lerptype.vecsize > 1)
return false;
// If our bool selects between 0 and 1, we can cast from bool instead, making our trivial constructor.
bool ret = false;
switch (type.basetype)
{
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
case SPIRType::Short:
case SPIRType::UShort:
ret = cleft->scalar_u16() == 0 && cright->scalar_u16() == 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
case SPIRType::Int:
case SPIRType::UInt:
ret = cleft->scalar() == 0 && cright->scalar() == 1;
break;
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
case SPIRType::Half:
ret = cleft->scalar_f16() == 0.0f && cright->scalar_f16() == 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
case SPIRType::Float:
ret = cleft->scalar_f32() == 0.0f && cright->scalar_f32() == 1.0f;
break;
case SPIRType::Double:
ret = cleft->scalar_f64() == 0.0 && cright->scalar_f64() == 1.0;
break;
case SPIRType::Int64:
case SPIRType::UInt64:
ret = cleft->scalar_u64() == 0 && cright->scalar_u64() == 1;
break;
default:
break;
}
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;
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
bool has_boolean_mix = backend.boolean_mix_support &&
((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
}
else
emit_trinary_func_op(result_type, id, left, right, lerp, "mix");
Initial commit.
2016-03-02 17:09:16 +00:00
}
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
string CompilerGLSL::to_combined_image_sampler(uint32_t image_id, uint32_t 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.
auto image_expr = to_expression(image_id);
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),
[image_id](const SPIRFunction::Parameter &param) { return param.id == image_id; });
auto sampler_itr = find_if(begin(args), end(args),
[samp_id](const SPIRFunction::Parameter &param) { return param.id == samp_id; });
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);
MSVC maintenance. Fix compilation and warnings.
2016-11-21 11:14:02 +00:00
uint32_t iid = global_image ? image_id : uint32_t(image_itr - begin(args));
uint32_t sid = global_sampler ? samp_id : 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
{
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(
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
"Cannot find mapping for combined sampler parameter, was build_combined_image_samplers() used "
"before compile() was called?");
}
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
}
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());
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.
forwarded_temporaries.erase(result_id);
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);
}
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
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::emit_texture_op(const Instruction &i)
{
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);
uint32_t length = i.length;
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
vector<uint32_t> inherited_expressions;
Add Clang format. Reformats the entire codebase. Better to do it now 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];
uint32_t img = ops[2];
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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;
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherited_expressions.push_back(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
switch (op)
{
case OpImageSampleDrefImplicitLod:
case OpImageSampleDrefExplicitLod:
dref = ops[4];
opt = &ops[5];
length -= 5;
break;
case OpImageSampleProjDrefImplicitLod:
case OpImageSampleProjDrefExplicitLod:
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:
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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:
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;
break;
case OpImageFetch:
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:
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;
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);
string 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
bool forward = false;
Run format_all.sh.
2017-01-13 15:32:54 +00:00
expr += to_function_name(img, imgtype, !!fetch, !!gather, !!proj, !!coffsets, (!!coffset || !!offset),
Check for legal lod id And avoid passing superfluous has_lod parameter.
2017-03-24 08:26:02 +00:00
(!!grad_x || !!grad_y), !!dref, lod);
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 += "(";
expr += to_function_args(img, imgtype, fetch, gather, proj, coord, coord_components, dref, grad_x, grad_y, lod,
coffset, offset, bias, comp, sample, &forward);
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
Added support for shadowXY() sample instructions in legacy GLSL
2018-06-22 07:28:40 +00:00
// texture(samplerXShadow) returns float. shadowX() returns vec4. Swizzle here.
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 (is_legacy() && image_is_comparison(imgtype, img))
Added support for shadowXY() sample instructions in legacy GLSL
2018-06-22 07:28:40 +00:00
expr += ".r";
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)
expr = remap_swizzle(get<SPIRType>(result_type), 4, 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
emit_op(result_type, id, expr, forward);
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
for (auto &inherit : inherited_expressions)
inherit_expression_dependencies(id, inherit);
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
switch (op)
{
case OpImageSampleDrefImplicitLod:
case OpImageSampleImplicitLod:
case OpImageSampleProjImplicitLod:
case OpImageSampleProjDrefImplicitLod:
register_control_dependent_expression(id);
break;
default:
break;
}
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();
}
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.
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
string CompilerGLSL::to_function_name(uint32_t tex, const SPIRType &imgtype, bool is_fetch, bool is_gather,
bool is_proj, bool has_array_offsets, bool has_offset, bool has_grad, bool,
uint32_t lod)
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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) &&
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
image_is_comparison(imgtype, tex) && lod)
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
{
MSL: Workaround missing gradient2d() for sampler_compare.
2019-01-07 09:01:00 +00:00
if (!expression_is_constant_null(lod))
{
Run format_all.sh.
2017-06-23 07:46:15 +00:00
SPIRV_CROSS_THROW(
Run format_all.sh.
2019-01-07 09:01:28 +00:00
"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 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
if (is_fetch)
fname += "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 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 += "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 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
if (is_gather)
fname += "Gather";
if (has_array_offsets)
fname += "Offsets";
if (is_proj)
fname += "Proj";
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 (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";
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 (!!lod && !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 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
if (has_offset)
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
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 is_legacy() ? legacy_tex_op(fname, imgtype, lod, 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
// Newer glslang supports this extension to deal with texture2D as argument to texture functions.
if (dummy_sampler_id)
SPIRV_CROSS_THROW("Vulkan GLSL should not have a dummy sampler for combining.");
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)
SPIRV_CROSS_THROW(
"Cannot find dummy sampler ID. Was build_dummy_sampler_for_combined_images() called?");
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
}
}
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_expression(id);
}
// Returns the function args for a texture sampling function for the specified image and sampling characteristics.
Run format_all.sh.
2018-04-30 10:46:21 +00:00
string CompilerGLSL::to_function_args(uint32_t img, const SPIRType &imgtype, bool is_fetch, bool is_gather,
bool is_proj, uint32_t coord, uint32_t coord_components, uint32_t dref,
uint32_t grad_x, uint32_t grad_y, uint32_t lod, uint32_t coffset, uint32_t offset,
uint32_t bias, uint32_t comp, uint32_t sample, 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
{
string farg_str;
if (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
farg_str = to_expression(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
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 "";
}
};
bool forward = should_forward(coord);
// The IR can give us more components than we need, so chop them off as needed.
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
auto swizzle_expr = swizzle(coord_components, expression_type(coord).vecsize);
// Only enclose the UV expression if needed.
auto coord_expr = (*swizzle_expr == '\0') ? to_expression(coord) : (to_enclosed_expression(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.
auto &coord_type = expression_type(coord);
if (coord_type.basetype == SPIRType::UInt)
{
auto expected_type = coord_type;
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) &&
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
image_is_comparison(imgtype, img) && 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
if (dref)
{
forward = forward && should_forward(dref);
// SPIR-V splits dref and coordinate.
Fix GatherDref on GLSL.
2018-04-30 10:45:23 +00:00
if (is_gather || 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 += ", ";
farg_str += to_expression(coord);
farg_str += ", ";
farg_str += to_expression(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
}
Fix textureProj with shadow on GLSL.
2017-07-31 08:05:32 +00:00
else if (is_proj)
{
// 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.
farg_str += to_enclosed_expression(coord) + ".x";
farg_str += ", ";
farg_str += "0.0, ";
farg_str += to_expression(dref);
farg_str += ", ";
farg_str += to_enclosed_expression(coord) + ".y)";
}
else if (imgtype.image.dim == Dim2D)
{
// Could reuse coord_expr, but we will mess up the temporary usage checking.
farg_str += to_enclosed_expression(coord) + (swizz_func ? ".xy()" : ".xy");
farg_str += ", ";
farg_str += to_expression(dref);
farg_str += ", ";
farg_str += to_enclosed_expression(coord) + ".z)";
}
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.
auto type = expression_type(coord);
type.vecsize = coord_components + 1;
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 += "(";
farg_str += coord_expr;
farg_str += ", ";
farg_str += to_expression(dref);
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
{
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
}
if (grad_x || grad_y)
{
forward = forward && should_forward(grad_x);
forward = forward && should_forward(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 += ", ";
farg_str += to_expression(grad_x);
farg_str += ", ";
farg_str += to_expression(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
}
if (lod)
{
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
{
if (check_explicit_lod_allowed(lod))
{
forward = forward && should_forward(lod);
farg_str += ", ";
farg_str += to_expression(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
}
Deal with OpImageFetch without explicit LOD.
2018-04-30 08:53:21 +00:00
else if (is_fetch && imgtype.image.dim != DimBuffer && !imgtype.image.ms)
{
// 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
if (coffset)
{
forward = forward && should_forward(coffset);
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 += to_expression(coffset);
Add Clang format. Reformats the entire codebase. Better to do it now 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 (offset)
{
forward = forward && should_forward(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 += ", ";
farg_str += to_expression(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
}
if (bias)
{
forward = forward && should_forward(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 += ", ";
farg_str += to_expression(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
}
if (comp)
{
forward = forward && should_forward(comp);
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 += to_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
}
Fix sampler2DMS texelFetch.
2016-06-22 10:35:58 +00:00
if (sample)
{
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 += to_expression(sample);
Fix sampler2DMS texelFetch.
2016-06-22 10:35:58 +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
}
void CompilerGLSL::emit_glsl_op(uint32_t result_type, uint32_t id, uint32_t eop, const uint32_t *args, uint32_t)
{
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
switch (op)
{
// FP fiddling
case GLSLstd450Round:
emit_unary_func_op(result_type, id, args[0], "round");
break;
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
case GLSLstd450RoundEven:
if ((options.es && options.version >= 300) || (!options.es && options.version >= 130))
emit_unary_func_op(result_type, id, args[0], "roundEven");
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("roundEven supported only in ESSL 300 and GLSL 130 and up.");
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:
emit_unary_func_op(result_type, id, args[0], "trunc");
break;
case GLSLstd450SAbs:
case GLSLstd450FAbs:
emit_unary_func_op(result_type, id, args[0], "abs");
break;
case GLSLstd450SSign:
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:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "fma");
break;
case GLSLstd450Modf:
register_call_out_argument(args[1]);
forced_temporaries.insert(id);
emit_binary_func_op(result_type, id, args[0], args[1], "modf");
break;
Support FrexpStruct/ModfStruct.
2017-09-04 08:24:21 +00:00
case GLSLstd450ModfStruct:
{
forced_temporaries.insert(id);
auto &type = get<SPIRType>(result_type);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = ir.meta[id].decoration.decoration_flags;
Support FrexpStruct/ModfStruct.
2017-09-04 08:24:21 +00:00
statement(flags_to_precision_qualifiers_glsl(type, flags), variable_decl(type, to_name(id)), ";");
set<SPIRExpression>(id, to_name(id), result_type, true);
statement(to_expression(id), ".", to_member_name(type, 0), " = ", "modf(", 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
// Minmax
case GLSLstd450UMin:
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
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
case GLSLstd450SMin:
emit_binary_func_op(result_type, id, args[0], args[1], "min");
break;
case GLSLstd450FMax:
case GLSLstd450UMax:
case GLSLstd450SMax:
emit_binary_func_op(result_type, id, args[0], args[1], "max");
break;
case GLSLstd450FClamp:
case GLSLstd450UClamp:
case GLSLstd450SClamp:
emit_trinary_func_op(result_type, id, args[0], args[1], args[2], "clamp");
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:
emit_unary_func_op(result_type, id, args[0], "sinh");
break;
case GLSLstd450Cosh:
emit_unary_func_op(result_type, id, args[0], "cosh");
break;
case GLSLstd450Tanh:
emit_unary_func_op(result_type, id, args[0], "tanh");
break;
case GLSLstd450Asinh:
emit_unary_func_op(result_type, id, args[0], "asinh");
break;
case GLSLstd450Acosh:
emit_unary_func_op(result_type, id, args[0], "acosh");
break;
case GLSLstd450Atanh:
emit_unary_func_op(result_type, id, args[0], "atanh");
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:
emit_unary_func_op(result_type, id, args[0], "determinant");
break;
case GLSLstd450MatrixInverse:
emit_unary_func_op(result_type, id, args[0], "inverse");
break;
// 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:
{
forced_temporaries.insert(id);
auto &type = get<SPIRType>(result_type);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = ir.meta[id].decoration.decoration_flags;
Support FrexpStruct/ModfStruct.
2017-09-04 08:24:21 +00:00
statement(flags_to_precision_qualifiers_glsl(type, flags), variable_decl(type, to_name(id)), ";");
set<SPIRExpression>(id, to_name(id), result_type, true);
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:
emit_binary_func_op(result_type, id, args[0], args[1], "ldexp");
break;
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:
emit_unary_func_op(result_type, id, args[0], "findLSB");
break;
case GLSLstd450FindSMsb:
case GLSLstd450FindUMsb:
emit_unary_func_op(result_type, id, args[0], "findMSB");
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:
emit_binary_func_op(result_type, id, args[0], args[1], "unsupported_glsl450_nmin");
break;
case GLSLstd450NMax:
emit_binary_func_op(result_type, id, args[0], args[1], "unsupported_glsl450_nmax");
break;
case GLSLstd450NClamp:
emit_binary_func_op(result_type, id, args[0], args[1], "unsupported_glsl450_nclamp");
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 GLSL op ", eop);
break;
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
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);
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Can only use subgroup operations in Vulkan semantics.");
switch (op)
{
case OpGroupNonUniformElect:
require_extension_internal("GL_KHR_shader_subgroup_basic");
break;
case OpGroupNonUniformBroadcast:
case OpGroupNonUniformBroadcastFirst:
case OpGroupNonUniformBallot:
case OpGroupNonUniformInverseBallot:
case OpGroupNonUniformBallotBitExtract:
case OpGroupNonUniformBallotBitCount:
case OpGroupNonUniformBallotFindLSB:
case OpGroupNonUniformBallotFindMSB:
require_extension_internal("GL_KHR_shader_subgroup_ballot");
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:
require_extension_internal("GL_KHR_shader_subgroup_vote");
break;
case OpGroupNonUniformFAdd:
case OpGroupNonUniformFMul:
case OpGroupNonUniformFMin:
case OpGroupNonUniformFMax:
Implement all of subgroup.
2018-04-10 15:16:41 +00:00
case OpGroupNonUniformIAdd:
case OpGroupNonUniformIMul:
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:
{
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];
auto scope = static_cast<Scope>(get<SPIRConstant>(ops[2]).scalar());
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; \
}
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_GROUP_OP(SMin, Min)
GLSL_GROUP_OP(SMax, Max)
GLSL_GROUP_OP(UMin, Min)
GLSL_GROUP_OP(UMax, Max)
GLSL_GROUP_OP(BitwiseAnd, And)
GLSL_GROUP_OP(BitwiseOr, Or)
GLSL_GROUP_OP(BitwiseXor, Xor)
#undef GLSL_GROUP_OP
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
{
uint32_t direction = get<SPIRConstant>(ops[4]).scalar();
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
{
Support bitcasts of 16-bit types.
2018-11-05 20:55:56 +00:00
if (out_type.basetype == SPIRType::UShort && in_type.basetype == SPIRType::Short)
return type_to_glsl(out_type);
else if (out_type.basetype == SPIRType::UInt && in_type.basetype == 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
return type_to_glsl(out_type);
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::Int64)
return type_to_glsl(out_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 if (out_type.basetype == SPIRType::UInt && in_type.basetype == SPIRType::Float)
return "floatBitsToUint";
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::UShort)
return type_to_glsl(out_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 if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::UInt)
return type_to_glsl(out_type);
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::UInt64)
return type_to_glsl(out_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 if (out_type.basetype == SPIRType::Int && in_type.basetype == SPIRType::Float)
return "floatBitsToInt";
else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::UInt)
return "uintBitsToFloat";
else if (out_type.basetype == SPIRType::Float && in_type.basetype == SPIRType::Int)
return "intBitsToFloat";
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";
Add support for new extensions.
2017-11-21 13:04:57 +00:00
else if (out_type.basetype == SPIRType::UInt64 && in_type.basetype == SPIRType::UInt && in_type.vecsize == 2)
return "packUint2x32";
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";
Add Clang format. Reformats the entire codebase. Better to do it now 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 "";
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())
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 to_enclosed_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
return join(op, "(", to_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:
return "gl_ClipDistance";
Add built-in cull distance.
2017-03-05 11:44:29 +00:00
case BuiltInCullDistance:
return "gl_CullDistance";
Add Clang format. Reformats the entire codebase. Better to do it now 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)
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(
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
"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)
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(
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
"Cannot implement gl_InstanceID 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_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";
Add support to remove SPIRV_Cross_BaseInstance uniform.
2018-06-22 08:01:38 +00:00
else if (options.vertex.support_nonzero_base_instance)
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.
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";
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";
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.");
Fix formatting.
2018-08-29 15:08:33 +00:00
if (options.version < 460)
{
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
require_extension_internal("GL_ARB_shader_draw_parameters");
return "gl_BaseVertexARB";
}
return "gl_BaseVertex";
case BuiltInBaseInstance:
if (options.es)
SPIRV_CROSS_THROW("BaseInstance not supported in ES profile.");
Fix formatting.
2018-08-29 15:08:33 +00:00
if (options.version < 460)
{
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
require_extension_internal("GL_ARB_shader_draw_parameters");
return "gl_BaseInstanceARB";
}
return "gl_BaseInstance";
case BuiltInDrawIndex:
if (options.es)
SPIRV_CROSS_THROW("DrawIndex not supported in ES profile.");
Fix formatting.
2018-08-29 15:08:33 +00:00
if (options.version < 460)
{
Support the shader_draw_parameters extension.
2018-08-28 18:47:29 +00:00
require_extension_internal("GL_ARB_shader_draw_parameters");
return "gl_DrawIDARB";
}
return "gl_DrawID";
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
case BuiltInSampleId:
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");
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
if (!options.es && options.version < 400)
SPIRV_CROSS_THROW("gl_SampleID not supported before GLSL 400.");
return "gl_SampleID";
case BuiltInSampleMask:
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");
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
if (!options.es && options.version < 400)
SPIRV_CROSS_THROW("gl_SampleMask/gl_SampleMaskIn not supported before GLSL 400.");
if (storage == StorageClassInput)
return "gl_SampleMaskIn";
else
return "gl_SampleMask";
case BuiltInSamplePosition:
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");
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
if (!options.es && options.version < 400)
SPIRV_CROSS_THROW("gl_SamplePosition not supported before GLSL 400.");
return "gl_SamplePosition";
Add support for SPV_KHR_multiview.
2017-08-15 11:28:16 +00:00
case BuiltInViewIndex:
if (options.vulkan_semantics)
{
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_EXT_multiview");
Add support for SPV_KHR_multiview.
2017-08-15 11:28:16 +00:00
return "gl_ViewIndex";
}
else
{
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_OVR_multiview2");
Add support for SPV_KHR_multiview.
2017-08-15 11:28:16 +00:00
return "gl_ViewID_OVR";
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
case BuiltInNumSubgroups:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for subgroup.");
require_extension_internal("GL_KHR_shader_subgroup_basic");
return "gl_NumSubgroups";
case BuiltInSubgroupId:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for subgroup.");
require_extension_internal("GL_KHR_shader_subgroup_basic");
return "gl_SubgroupID";
case BuiltInSubgroupSize:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for subgroup.");
require_extension_internal("GL_KHR_shader_subgroup_basic");
return "gl_SubgroupSize";
case BuiltInSubgroupLocalInvocationId:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for subgroup.");
require_extension_internal("GL_KHR_shader_subgroup_basic");
return "gl_SubgroupInvocationID";
case BuiltInSubgroupEqMask:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for subgroup.");
require_extension_internal("GL_KHR_shader_subgroup_ballot");
return "gl_SubgroupEqMask";
case BuiltInSubgroupGeMask:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for subgroup.");
require_extension_internal("GL_KHR_shader_subgroup_ballot");
return "gl_SubgroupGeMask";
case BuiltInSubgroupGtMask:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for subgroup.");
require_extension_internal("GL_KHR_shader_subgroup_ballot");
return "gl_SubgroupGtMask";
case BuiltInSubgroupLeMask:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for subgroup.");
require_extension_internal("GL_KHR_shader_subgroup_ballot");
return "gl_SubgroupLeMask";
case BuiltInSubgroupLtMask:
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Need Vulkan semantics for subgroup.");
require_extension_internal("GL_KHR_shader_subgroup_ballot");
return "gl_SubgroupLtMask";
Add Clang format. Reformats the entire codebase. Better to do it now 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:
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("Swizzle index out of range");
Add Clang format. Reformats the entire codebase. Better to do it now 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
}
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;
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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)
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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);
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(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
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);
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
bool is_packed = has_extended_decoration(base, SPIRVCrossDecorationPacked);
uint32_t packed_type = get_extended_decoration(base, SPIRVCrossDecorationPackedType);
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);
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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];
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
const auto append_index = [&]() {
expr += "[";
if (index_is_literal)
expr += convert_to_string(index);
else
expr += to_expression(index, register_expression_read);
expr += "]";
};
// Pointer chains
if (ptr_chain && i == 0)
{
// 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.
if (index_is_literal)
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
{
append_index();
}
access_chain_is_arrayed = 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
// 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.
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;
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)
{
Formatting.
2018-01-09 11:51:21 +00:00
// case BuiltInCullDistance: // These are already arrays, need to figure out rules for these in tess/geom.
// case BuiltInClipDistance:
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:
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
append_index();
break;
default:
append_index();
break;
}
}
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);
if (index_is_literal)
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
}
else
{
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
append_index();
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +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
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
access_chain_is_arrayed = true;
}
// 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)
{
if (!index_is_literal)
index = get<SPIRConstant>(index).scalar();
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
BuiltIn builtin;
if (is_member_builtin(*type, index, &builtin))
{
// FIXME: We rely here on OpName on gl_in/gl_out to make this work properly.
// To make this properly work by omitting all OpName opcodes,
// we need to infer gl_in or gl_out based on the builtin, and stage.
if (access_chain_is_arrayed)
{
expr += ".";
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
expr += builtin_to_glsl(builtin, type->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
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
expr = builtin_to_glsl(builtin, type->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
{
CompilerMSL fix variables used in interface blocks aren't resolved correctly (#179).
2017-05-23 01:41:19 +00:00
// If the member has a qualified name, use it as the entire chain
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
string qual_mbr_name = get_member_qualified_name(type_id, index);
CompilerMSL fix variables used in interface blocks aren't resolved correctly (#179).
2017-05-23 01:41:19 +00:00
if (!qual_mbr_name.empty())
expr = qual_mbr_name;
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
expr += to_member_reference(base, *type, index, ptr_chain);
Add Clang format. Reformats the entire codebase. Better to do it now 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;
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
is_packed = member_is_packed_type(*type, index);
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
if (is_packed)
packed_type = get_extended_member_decoration(type->self, index, SPIRVCrossDecorationPackedType);
else
packed_type = 0;
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)
{
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
if (row_major_matrix_needs_conversion)
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
{
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
expr = convert_row_major_matrix(expr, *type, is_packed);
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 = false;
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
is_packed = false;
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
packed_type = 0;
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 += "[";
if (index_is_literal)
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_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 += "]";
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)
{
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
if (index_is_literal && !is_packed)
Add Clang format. Reformats the entire codebase. Better to do it now 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 += ".";
expr += index_to_swizzle(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
else if (ir.ids[index].get_type() == TypeConstant && !is_packed)
Add Clang format. Reformats the entire codebase. Better to do it now 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);
expr += ".";
expr += index_to_swizzle(c.scalar());
}
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
else if (index_is_literal)
{
// For packed vectors, we can only access them as an array, not by swizzle.
expr += join("[", 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
else
{
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
expr += to_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 += "]";
}
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;
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
packed_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;
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
meta->storage_packed_type = packed_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
}
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
}
Flatten structs based on instance name rather than block name. Block name is too brittle, optimizes will merge block types, making flattening impossible with unique names.
2018-01-09 09:36:04 +00:00
string CompilerGLSL::to_flattened_struct_member(const SPIRVariable &var, uint32_t index)
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
{
Flatten structs based on instance name rather than block name. Block name is too brittle, optimizes will merge block types, making flattening impossible with unique names.
2018-01-09 09:36:04 +00:00
auto &type = get<SPIRType>(var.basetype);
return sanitize_underscores(join(to_name(var.self), "_", to_member_name(type, index)));
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
}
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;
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,
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
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(base, indices, count, target_type, 0, 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
}
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;
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;
}
Flatten structs based on instance name rather than block name. Block name is too brittle, optimizes will merge block types, making flattening impossible with unique names.
2018-01-09 09:36:04 +00:00
return sanitize_underscores(join(to_name(base), "_", chain));
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)
flags |= ACCESS_CHAIN_PTR_CHAIN_BIT;
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
}
}
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
string CompilerGLSL::load_flattened_struct(SPIRVariable &var)
{
auto expr = type_to_glsl_constructor(get<SPIRType>(var.basetype));
expr += '(';
auto &type = get<SPIRType>(var.basetype);
for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++)
{
if (i)
expr += ", ";
// Flatten the varyings.
// Apply name transformation for flattened I/O blocks.
Flatten structs based on instance name rather than block name. Block name is too brittle, optimizes will merge block types, making flattening impossible with unique names.
2018-01-09 09:36:04 +00:00
expr += to_flattened_struct_member(var, i);
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
}
expr += ')';
return expr;
}
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
void CompilerGLSL::store_flattened_struct(SPIRVariable &var, uint32_t value)
{
// We're trying to store a structure which has been flattened.
// Need to copy members one by one.
auto rhs = to_expression(value);
// Store result locally.
// Since we're declaring a variable potentially multiple times here,
// store the variable in an isolated scope.
begin_scope();
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), " = ", rhs, ";");
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
auto &type = get<SPIRType>(var.basetype);
for (uint32_t i = 0; i < uint32_t(type.member_types.size()); i++)
{
// Flatten the varyings.
// Apply name transformation for flattened I/O blocks.
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
Flatten structs based on instance name rather than block name. Block name is too brittle, optimizes will merge block types, making flattening impossible with unique names.
2018-01-09 09:36:04 +00:00
auto lhs = sanitize_underscores(join(to_name(var.self), "_", to_member_name(type, i)));
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
rhs = join(to_name(var.self), ".", to_member_name(type, i));
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
statement(lhs, " = ", rhs, ";");
}
end_scope();
}
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,
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;
Add flattening support for push constants.
2017-01-21 09:27:14 +00:00
expr += type_to_glsl_constructor(target_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 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;
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
{
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
need_transpose = combined_decoration_for_member(target_type, i).get(DecorationRowMajor);
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,
need_transpose);
// 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)
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
expr += convert_row_major_matrix(tmp, member_type, false);
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
}
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
}
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,
bool *need_transpose, uint32_t *out_matrix_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
Comment type ID a bit better.
2017-01-22 08:06:15 +00:00
// This holds the type of the current pointer which we are traversing through.
// We always start out from a struct type which is the block.
// This is primarily used to reflect the array strides and matrix strides later.
// For the first access chain index, type_id won't be needed, so just keep it as 0, it will be set
// accordingly as members of structs are accessed.
assert(type->basetype == SPIRType::Struct);
uint32_t type_id = 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
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;
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.
uint32_t array_stride = get_decoration(basetype.self, DecorationArrayStride);
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)
{
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.");
}
expr += to_enclosed_expression(index);
expr += " * ";
expr += convert_to_string(array_stride / word_stride);
expr += " + ";
}
// Type ID is unchanged.
}
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
{
Comment type ID a bit better.
2017-01-22 08:06:15 +00:00
// Here, the type_id will be a type ID for the array type itself.
uint32_t array_stride = get_decoration(type_id, DecorationArrayStride);
Cleanups for flattened access chains.
2017-01-21 10:30:33 +00:00
if (!array_stride)
SPIRV_CROSS_THROW("SPIR-V does not define ArrayStride for buffer block.");
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)
{
Formatting.
2017-01-21 11:47:26 +00:00
SPIRV_CROSS_THROW(
"Array stride for dynamic indexing must be divisible by the size of a 4-component vector. "
Comment type ID a bit better.
2017-01-22 08:06:15 +00:00
"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
type_id = parent_type;
// Type ID now refers to the array type with one less dimension.
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)
{
Remove hack for accessing matrix decorations in flattened structs.
2017-01-22 08:21:22 +00:00
index = get<SPIRConstant>(index).scalar();
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);
Comment type ID a bit better.
2017-01-22 08:06:15 +00:00
type_id = type->member_types[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;
Add Clang format. Reformats the entire codebase. Better to do it now 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)
{
index = get<SPIRConstant>(index).scalar();
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)
{
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.");
}
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
uint32_t parent_type = type->parent_type;
type = &get<SPIRType>(type->parent_type);
Comment type ID a bit better.
2017-01-22 08:06:15 +00:00
type_id = 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)
{
index = get<SPIRConstant>(index).scalar();
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)
{
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.");
}
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
uint32_t parent_type = type->parent_type;
type = &get<SPIRType>(type->parent_type);
Comment type ID a bit better.
2017-01-22 08:06:15 +00:00
type_id = 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;
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 id is an access chain, we should not dereference it.
if (auto *expr = maybe_get<SPIRExpression>(id))
return !expr->access_chain;
// Otherwise, we should dereference this pointer expression.
return true;
}
Initial commit.
2016-03-02 17:09:16 +00:00
bool CompilerGLSL::should_forward(uint32_t id)
{
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
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);
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 (var && var->forwardable)
return true;
// For debugging emit temporary variables for all expressions
if (options.force_temporary)
return false;
// Immutable expression can always be forwarded.
if (is_immutable(id))
return true;
return false;
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.
if (expression_is_forwarded(id))
{
auto &v = expression_usage_counts[id];
v++;
if (v >= 2)
{
//if (v == 2)
// fprintf(stderr, "ID %u was forced to temporary due to more than 1 expression use!\n", id);
forced_temporaries.insert(id);
// Force a recompile after this pass to avoid forwarding this variable.
force_recompile = true;
}
}
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;
}
Initial commit.
2016-03-02 17:09:16 +00:00
void CompilerGLSL::flush_variable_declaration(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 *var = maybe_get<SPIRVariable>(id);
if (var && var->deferred_declaration)
{
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), ";");
Deal with phi copies which happen inside continue blocks.
2019-01-07 13:19:27 +00:00
if (var->allocate_temporary_copy)
{
auto &type = get<SPIRType>(var->basetype);
auto &flags = ir.meta[id].decoration.decoration_flags;
statement(flags_to_precision_qualifiers_glsl(type, flags), variable_decl(type, join("_", id, "_copy")),
";");
}
Add Clang format. Reformats the entire codebase. Better to do it now 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;
}
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 ...
assert(type.columns == 1 && type.array.empty());
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
{
Add Clang format. Reformats the entire codebase. Better to do it now 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 base = 0;
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 += ", ";
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
subop = to_expression(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
}
base = e ? e->base_expression : 0;
}
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);
// 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;
for (auto &op : block.ops)
emit_instruction(op);
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)
{
if (forwarded_temporaries.count(expr.self))
{
forced_temporaries.insert(expr.self);
force_recompile = true;
}
for (auto &dependent : expr.expression_dependencies)
disallow_forwarding_in_expression_chain(get<SPIRExpression>(dependent));
}
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);
auto lhs = to_dereferenced_expression(lhs_expression);
// We might need to bitcast in order to store to a builtin.
bitcast_to_builtin_store(lhs_expression, rhs, expression_type(rhs_expression));
// 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, ";");
register_write(lhs_expression);
}
}
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) \
Uniquely name these static functions
2018-02-03 22:23:30 +00:00
emit_binary_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, glsl_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_UOP(op) emit_unary_op(ops[0], ops[1], ops[2], #op)
#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) \
Uniquely name these static functions
2018-02-03 22:23:30 +00:00
emit_binary_func_op_cast(ops[0], ops[1], ops[2], ops[3], #op, type, glsl_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
Add Clang format. Reformats the entire codebase. Better to do it now 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);
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;
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.
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 expr = to_dereferenced_expression(ptr, !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 with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
// We might need to bitcast in order to load from a builtin.
bitcast_from_builtin_load(ptr, expr, get<SPIRType>(result_type));
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 (ptr_expression)
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
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.
auto &type = get<SPIRType>(result_type);
bool usage_tracking = ptr_expression && flattened_buffer_blocks.count(ptr_expression->loaded_from) != 0 &&
(type.basetype == SPIRType::Struct || (type.columns > 1));
auto &e = emit_op(result_type, id, expr, forward, !usage_tracking);
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 = 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
// Pass through whether the result is of a packed type.
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
if (has_extended_decoration(ptr, SPIRVCrossDecorationPacked))
{
set_extended_decoration(id, SPIRVCrossDecorationPacked);
set_extended_decoration(id, SPIRVCrossDecorationPackedType,
get_extended_decoration(ptr, SPIRVCrossDecorationPackedType));
}
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)
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;
auto e = access_chain(ops[2], &ops[3], length - 3, get<SPIRType>(ops[0]), &meta, ptr_chain);
Fix a lot of redundant code when loading flattened composites.
2018-07-06 08:57:23 +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 &expr = set<SPIRExpression>(ops[1], 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]);
expr.loaded_from = backing_variable ? backing_variable->self : 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;
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)
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
set_extended_decoration(ops[1], SPIRVCrossDecorationPacked);
if (meta.storage_packed_type != 0)
set_extended_decoration(ops[1], SPIRVCrossDecorationPackedType, meta.storage_packed_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);
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]);
}
Add Clang format. Reformats the entire codebase. Better to do it now 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];
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
else if (var && var->remapped_variable)
{
// Skip the write.
}
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
else if (var && 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
{
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
store_flattened_struct(*var, 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);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
set<SPIRExpression>(id, e + ".length()", result_type, true);
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);
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;
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
vector<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)
{
statement(type_to_glsl(return_type), " ", to_name(id), type_to_array_glsl(return_type), ";");
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;
Run clang-format.
2016-10-24 13:24:24 +00:00
arglist.push_back(to_func_call_arg(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)
{
Consistently use "image" nomenclature for separate images.
2016-09-11 11:47:06 +00:00
uint32_t image_id = combined.global_image ? combined.image_id : arg[combined.image_id];
Pass down combined samplers to callees.
2016-09-11 11:20:35 +00:00
uint32_t sampler_id = combined.global_sampler ? combined.sampler_id : 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, ";");
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: Support array-of-arrays composite construction.
2018-09-12 08:25:51 +00:00
if (!backend.array_is_value_type && out_type.array.size() > 1)
{
// We cannot construct array of arrays because we cannot treat the inputs
// as value types. Need to declare the array-of-arrays, and copy in elements one by one.
forced_temporaries.insert(id);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = ir.meta[id].decoration.decoration_flags;
Run format_all.sh.
2018-09-12 08:53:50 +00:00
statement(flags_to_precision_qualifiers_glsl(out_type, flags), variable_decl(out_type, to_name(id)), ";");
MSL: Support array-of-arrays composite construction.
2018-09-12 08:25:51 +00:00
set<SPIRExpression>(id, to_name(id), result_type, true);
for (uint32_t i = 0; i < length; i++)
emit_array_copy(join(to_expression(id), "[", i, "]"), elems[i]);
}
else 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
{
// 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));
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 += "{ ";
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)
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 += to_expression(elems[0]);
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 += " }";
}
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
{
constructor_op = remap_swizzle(get<SPIRType>(result_type), 1, to_expression(elems[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
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)
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 += to_expression(elems[0]);
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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(chain, " = ", to_expression(comp), ";");
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]);
Do not allow base expressions for arrays either.
2017-11-22 11:07:37 +00:00
if (composite_type.basetype == SPIRType::Struct || !composite_type.array.empty())
Do not allow base expressions when extracting struct members.
2017-11-20 20:32:13 +00:00
allow_base_expression = 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
// Packed expressions cannot be split up.
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
if (has_extended_decoration(ops[2], SPIRVCrossDecorationPacked))
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;
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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 apply this optimization if result is scalar.
Only split expression in OpCompositeExtract if we forward the temporary.
2016-06-23 10:11:36 +00:00
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
{
// 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,
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT | ACCESS_CHAIN_CHAIN_ONLY_BIT, &meta);
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 = &emit_op(result_type, id, expr, true, !expression_is_forwarded(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];
Add Clang format. Reformats the entire codebase. Better to do it now 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 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, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, &meta);
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 = &emit_op(result_type, id, expr, should_forward(ops[2]), !expression_is_forwarded(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)
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
set_extended_decoration(id, SPIRVCrossDecorationPacked);
if (meta.storage_packed_type != 0)
set_extended_decoration(id, SPIRVCrossDecorationPackedType, meta.storage_packed_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);
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
// 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);
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
auto chain = access_chain_internal(id, elems, length, ACCESS_CHAIN_INDEX_IS_LITERAL_BIT, nullptr);
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
statement(chain, " = ", to_expression(obj), ";");
Add Clang format. Reformats the entire codebase. Better to do it now 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)
{
flush_variable_declaration(lhs);
flush_variable_declaration(rhs);
statement(to_expression(lhs), " = ", to_expression(rhs), ";");
register_write(lhs);
}
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;
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.
Add Clang format. Reformats the entire codebase. Better to do it now 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(declare_temporary(result_type, id), to_expression(rhs), ";");
set<SPIRExpression>(id, to_name(id), result_type, true);
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(id, rhs);
Add Clang format. Reformats the entire codebase. Better to do it now 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.
Distinguish between cross edges and back edges. Handle the weird opcodes CopyMemory/CopyObject.
2016-11-18 08:59:54 +00:00
auto &e = set<SPIRExpression>(id, to_expression(rhs), result_type, true);
if (pointer)
{
auto *var = maybe_get_backing_variable(rhs);
e.loaded_from = var ? var->self : 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 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);
bool shuffle = false;
for (uint32_t i = 0; i < length; i++)
if (elems[i] >= type0.vecsize)
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.
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
if (!shuffle && has_extended_decoration(vec0, SPIRVCrossDecorationPacked))
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);
trivial_forward = !expression_is_forwarded(vec0) && !expression_is_forwarded(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.
vector<string> args;
for (uint32_t i = 0; i < length; i++)
{
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);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
trivial_forward = !expression_is_forwarded(vec0);
// 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++)
expr += index_to_swizzle(elems[i]);
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);
Expand the implementation of inherit_expression_dependencies.
2018-03-09 12:21:38 +00:00
inherit_expression_dependencies(id, vec0);
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:
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(isnan);
Add Clang format. Reformats the entire codebase. Better to do it now 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:
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(isinf);
Add Clang format. Reformats the entire codebase. Better to do it now 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:
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;
emit_binary_op(ops[0], ops[1], ops[3], ops[2], "*");
e->need_transpose = true;
}
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;
}
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 OpMatrixTimesScalar:
case OpVectorTimesScalar:
case OpMatrixTimesMatrix:
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:
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(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:
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(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];
// Needs special handling.
bool forward = should_forward(op0) && should_forward(op1);
auto expr = join(to_enclosed_expression(op0), " - ", to_enclosed_expression(op1), " * ", "(",
to_enclosed_expression(op0), " / ", to_enclosed_expression(op1), ")");
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:
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(/, SPIRType::Int);
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:
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(/, SPIRType::UInt);
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];
forced_temporaries.insert(result_id);
auto &type = get<SPIRType>(result_type);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = ir.meta[result_id].decoration.decoration_flags;
GLSL: Support extended arithmetic opcodes. - uaddCarry - usubBorrow - umulExtended - imulExtended
2018-11-13 13:50:17 +00:00
statement(flags_to_precision_qualifiers_glsl(type, flags), variable_decl(type, to_name(result_id)), ";");
set<SPIRExpression>(result_id, to_name(result_id), result_type, true);
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];
forced_temporaries.insert(result_id);
auto &type = get<SPIRType>(result_type);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = ir.meta[result_id].decoration.decoration_flags;
GLSL: Support extended arithmetic opcodes. - uaddCarry - usubBorrow - umulExtended - imulExtended
2018-11-13 13:50:17 +00:00
statement(flags_to_precision_qualifiers_glsl(type, flags), variable_decl(type, to_name(result_id)), ";");
set<SPIRExpression>(result_id, to_name(result_id), result_type, true);
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:
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(>>, SPIRType::UInt);
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:
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(>>, 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;
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:
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 OpUMod:
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(%, SPIRType::UInt);
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:
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(%, 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;
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:
{
if (is_legacy())
Run format_all.sh.
2018-02-15 12:32:49 +00:00
SPIRV_CROSS_THROW("OpFRem requires trunc() and is only supported on non-legacy targets. A workaround is "
"needed for legacy.");
Implement FRem.
2018-02-15 12:31:29 +00:00
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);
Run format_all.sh.
2018-02-15 12:32:49 +00:00
auto expr = join(to_enclosed_expression(op0), " - ", to_enclosed_expression(op1), " * ", "trunc(",
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)
emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "||");
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)
emit_unrolled_binary_op(result_type, id, ops[2], ops[3], "&&");
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)
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(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)
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(equal, SPIRType::Int);
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(==, SPIRType::Int);
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)
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(notEqual, SPIRType::Int);
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(!=, SPIRType::Int);
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:
{
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
{
auto type = opcode == OpUGreaterThan ? SPIRType::UInt : SPIRType::Int;
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
{
auto type = opcode == OpUGreaterThanEqual ? SPIRType::UInt : SPIRType::Int;
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
{
auto type = opcode == OpULessThan ? SPIRType::UInt : SPIRType::Int;
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
{
auto type = opcode == OpULessThanEqual ? SPIRType::UInt : SPIRType::Int;
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
case OpConvertFToU:
case OpConvertFToS:
case OpConvertSToF:
case OpConvertUToF:
case OpUConvert:
case OpSConvert:
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];
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(get<SPIRType>(result_type), expression_type(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
emit_unary_func_op(result_type, id, arg, op.c_str());
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:
Fix bitfield functions.
2017-03-25 14:38:20 +00:00
// TODO: The signedness of inputs is strict in GLSL, but not in SPIR-V, bitcast if necessary.
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_QFOP(bitfieldInsert);
Add Clang format. Reformats the entire codebase. Better to do it now 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 OpBitFieldSExtract:
case OpBitFieldUExtract:
Fix bitfield functions.
2017-03-25 14:38:20 +00:00
// TODO: The signedness of inputs is strict in GLSL, but not in SPIR-V, bitcast if necessary.
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_TFOP(bitfieldExtract);
Add Clang format. Reformats the entire codebase. Better to do it now 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 OpBitReverse:
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:
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(bitCount);
Add Clang format. Reformats the entire codebase. Better to do it now 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;
// 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";
forced_temporaries.insert(id);
emit_binary_func_op(result_type, id, ptr, val, op);
flush_all_atomic_capable_variables();
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";
forced_temporaries.insert(id);
emit_trinary_func_op(result_type, id, ptr, comp, val, op);
flush_all_atomic_capable_variables();
break;
}
case OpAtomicLoad:
flush_all_atomic_capable_variables();
// FIXME: Image?
Formatting.
2018-01-09 11:51:21 +00:00
// OpAtomicLoad seems to only be relevant for atomic counters.
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(atomicCounter);
Add Clang format. Reformats the entire codebase. Better to do it now 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_read(ops[1], ops[2], should_forward(ops[2]));
break;
Formatting.
2018-01-09 11:51:21 +00:00
case OpAtomicStore:
SPIRV_CROSS_THROW("Unsupported opcode OpAtomicStore.");
Add Clang format. Reformats the entire codebase. Better to do it now 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";
emit_op(ops[0], ops[1], join(op, "(", to_expression(ops[2]), ", ", increment, ")"), 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
flush_all_atomic_capable_variables();
register_read(ops[1], ops[2], should_forward(ops[2]));
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:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicAdd" : "atomicAdd";
forced_temporaries.insert(ops[1]);
emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op);
flush_all_atomic_capable_variables();
register_read(ops[1], ops[2], should_forward(ops[2]));
break;
}
case OpAtomicISub:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicAdd" : "atomicAdd";
forced_temporaries.insert(ops[1]);
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
auto expr = join(op, "(", to_expression(ops[2]), ", -", to_enclosed_expression(ops[5]), ")");
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();
register_read(ops[1], ops[2], should_forward(ops[2]));
break;
}
case OpAtomicSMin:
case OpAtomicUMin:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicMin" : "atomicMin";
forced_temporaries.insert(ops[1]);
emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op);
flush_all_atomic_capable_variables();
register_read(ops[1], ops[2], should_forward(ops[2]));
break;
}
case OpAtomicSMax:
case OpAtomicUMax:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicMax" : "atomicMax";
forced_temporaries.insert(ops[1]);
emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op);
flush_all_atomic_capable_variables();
register_read(ops[1], ops[2], should_forward(ops[2]));
break;
}
case OpAtomicAnd:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicAnd" : "atomicAnd";
forced_temporaries.insert(ops[1]);
emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op);
flush_all_atomic_capable_variables();
register_read(ops[1], ops[2], should_forward(ops[2]));
break;
}
case OpAtomicOr:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicOr" : "atomicOr";
forced_temporaries.insert(ops[1]);
emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op);
flush_all_atomic_capable_variables();
register_read(ops[1], ops[2], should_forward(ops[2]));
break;
}
case OpAtomicXor:
{
const char *op = check_atomic_image(ops[2]) ? "imageAtomicXor" : "atomicXor";
forced_temporaries.insert(ops[1]);
emit_binary_func_op(ops[0], ops[1], ops[2], ops[5], op);
flush_all_atomic_capable_variables();
register_read(ops[1], ops[2], should_forward(ops[2]));
break;
}
// Geometry shaders
case OpEmitVertex:
statement("EmitVertex();");
break;
case OpEndPrimitive:
statement("EndPrimitive();");
break;
case OpEmitStreamVertex:
statement("EmitStreamVertex();");
break;
case OpEndStreamPrimitive:
statement("EndStreamPrimitive();");
break;
// 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.
emit_texture_op(instruction);
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]);
e.loaded_from = var ? var->self : 0;
break;
}
Add support for OpImageQueryLod.
2016-07-19 07:22:54 +00:00
case OpImageQueryLod:
{
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.
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(textureQueryLOD);
Add support for OpImageQueryLod.
2016-07-19 07:22:54 +00:00
}
else 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("textureQueryLod not supported in ES profile.");
Add support for OpImageQueryLod.
2016-07-19 07:22:54 +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_BFOP(textureQueryLod);
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
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
string expr;
if (type.image.sampled == 2)
expr = join("imageSamples(", to_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]);
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];
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
auto expr = join("textureSize(", convert_separate_image_to_expression(ops[2]), ", ",
Run format_all.sh.
2018-04-30 10:46:21 +00:00
bitcast_expression(SPIRType::Int, ops[3]), ")");
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:
{
// 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)
{
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 &flags = ir.meta[var->self].decoration.decoration_flags;
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
{
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
flags.clear(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
force_recompile = true;
}
}
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)
{
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)
{
// 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)
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(
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
"Multisampled image used in OpImageRead, but unexpected operand mask was used.");
uint32_t samples = ops[5];
imgexpr = join("subpassLoad(", to_expression(ops[2]), ", ", to_expression(samples), ")");
}
else
imgexpr = join("subpassLoad(", to_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)
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(
Implement subpassInputMS loading.
2016-07-11 11:36:11 +00:00
"Multisampled image used in OpImageRead, but unexpected operand mask was used.");
uint32_t samples = ops[5];
imgexpr = join("texelFetch(", to_expression(ops[2]), ", ivec2(gl_FragCoord.xy), ",
to_expression(samples), ")");
}
else
{
// Implement subpass loads via texture barrier style sampling.
imgexpr = join("texelFetch(", to_expression(ops[2]), ", ivec2(gl_FragCoord.xy), 0)");
}
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
{
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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.
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
if (type.image.ms)
{
uint32_t operands = ops[4];
if (operands != ImageOperandsSampleMask || length != 6)
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 OpImageRead, but unexpected operand mask was used.");
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
uint32_t samples = ops[5];
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
imgexpr =
join("imageLoad(", to_expression(ops[2]), ", ", coord_expr, ", ", to_expression(samples), ")");
Support ImageRead/Write on multisampled images.
2016-07-11 11:25:37 +00:00
}
else
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
imgexpr = join("imageLoad(", to_expression(ops[2]), ", ", coord_expr, ")");
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 = false;
}
if (var && var->forwardable)
{
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];
auto &e = set<SPIRExpression>(id, join(to_expression(ops[2]), ", ", to_expression(ops[3])), result_type, true);
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]);
e.loaded_from = var ? var->self : 0;
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)
{
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 &flags = ir.meta[var->self].decoration.decoration_flags;
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
{
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
flags.clear(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
force_recompile = true;
}
}
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);
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];
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
statement("imageStore(", to_expression(ops[0]), ", ", coord_expr, ", ", to_expression(samples), ", ",
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
Make sure image integer coords are int, not uint. HLSL can emit uint here.
2017-12-01 14:01:56 +00:00
statement("imageStore(", to_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)
{
// The size of an image is always constant.
expr = join("imageSize(", to_expression(ops[2]), ")");
}
else
{
// This path is hit for samplerBuffers and multisampled images which do not have LOD.
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
expr = join("textureSize(", 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;
}
// 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)
{
memory = get<SPIRConstant>(ops[0]).scalar();
semantics = get<SPIRConstant>(ops[1]).scalar();
}
else
{
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
execution_scope = get<SPIRConstant>(ops[0]).scalar();
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
memory = get<SPIRConstant>(ops[1]).scalar();
semantics = get<SPIRConstant>(ops[2]).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
}
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
if (execution_scope == ScopeSubgroup || memory == ScopeSubgroup)
{
if (!options.vulkan_semantics)
SPIRV_CROSS_THROW("Can only use subgroup operations in Vulkan semantics.");
require_extension_internal("GL_KHR_shader_subgroup_basic");
}
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);
uint32_t next_memory = get<SPIRConstant>(next_ops[1]).scalar();
uint32_t next_semantics = get<SPIRConstant>(next_ops[2]).scalar();
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)
statement("memoryBarrierShared();");
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
{
Formatting.
2018-01-09 11:51:21 +00:00
const uint32_t all_barriers = MemorySemanticsWorkgroupMemoryMask | MemorySemanticsUniformMemoryMask |
MemorySemanticsImageMemoryMask | MemorySemanticsAtomicCounterMemoryMask;
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 (semantics & MemorySemanticsAtomicCounterMemoryMask)
statement("memoryBarrierAtomicCounter();");
}
}
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];
Add support for new extensions.
2017-11-21 13:04:57 +00:00
if (get<SPIRExtension>(extension_set).ext == SPIRExtension::GLSL)
{
emit_glsl_op(ops[0], ops[1], ops[3], &ops[4], length - 4);
}
else if (get<SPIRExtension>(extension_set).ext == SPIRExtension::SPV_AMD_shader_ballot)
{
emit_spv_amd_shader_ballot_op(ops[0], ops[1], ops[3], &ops[4], length - 4);
}
else if (get<SPIRExtension>(extension_set).ext == SPIRExtension::SPV_AMD_shader_explicit_vertex_parameter)
{
emit_spv_amd_shader_explicit_vertex_parameter_op(ops[0], ops[1], ops[3], &ops[4], length - 4);
}
else if (get<SPIRExtension>(extension_set).ext == SPIRExtension::SPV_AMD_shader_trinary_minmax)
{
emit_spv_amd_shader_trinary_minmax_op(ops[0], ops[1], ops[3], &ops[4], length - 4);
}
else if (get<SPIRExtension>(extension_set).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);
}
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:
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:
GLSL_BFOP(unsupported_FUnordEqual);
break;
case OpFUnordNotEqual:
GLSL_BFOP(unsupported_FUnordNotEqual);
break;
case OpFUnordLessThan:
GLSL_BFOP(unsupported_FUnordLessThan);
break;
case OpFUnordGreaterThan:
GLSL_BFOP(unsupported_FUnordGreaterThan);
break;
case OpFUnordLessThanEqual:
GLSL_BFOP(unsupported_FUnordLessThanEqual);
break;
case OpFUnordGreaterThanEqual:
GLSL_BFOP(unsupported_FUnordGreaterThanEqual);
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.
Merge Brenwill fork with upstream.
2016-10-19 21:09:51 +00:00
void CompilerGLSL::append_global_func_args(const SPIRFunction &func, uint32_t index, vector<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
arglist.push_back(to_func_call_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)
{
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));
}
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;
// Reserved for temporaries.
if (name[0] == '_' && name.size() >= 2 && isdigit(name[1]))
{
name.clear();
return;
}
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;
// Non-matrix or column-major matrix types do not need to be converted.
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.meta[id].decoration.decoration_flags.get(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 type = expression_type(id);
if (type.columns != 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
}
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.
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (!combined_decoration_for_member(type, index).get(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
}
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.
// GLSL does not define packed data types, but certain subclasses do.
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
bool CompilerGLSL::member_is_packed_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
{
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
return has_extended_member_decoration(type.self, index, SPIRVCrossDecorationPacked);
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.
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
string CompilerGLSL::convert_row_major_matrix(string exp_str, const SPIRType & /*exp_type*/, bool /*is_packed*/)
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);
return join("transpose(", exp_str, ")");
}
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);
Add support of variable type remapping
2016-09-20 08:17:41 +00:00
return join(type_name, " ", name, type_to_array_glsl(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
}
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);
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
statement(layout_for_member(type, index), qualifiers, qualifier,
flags_to_precision_qualifiers_glsl(membertype, memberflags),
variable_decl(membertype, to_member_name(type, index)), ";");
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
const char *CompilerGLSL::flags_to_precision_qualifiers_glsl(const SPIRType &type, const Bitset &flags)
Initial commit.
2016-03-02 17:09:16 +00:00
{
Support mediump in desktop Vulkan GLSL.
2017-12-06 09:25:30 +00:00
// Structs do not have precision qualifiers, neither do doubles (desktop only anyways, so no mediump/highp).
if (type.basetype != SPIRType::Float && type.basetype != SPIRType::Int && type.basetype != SPIRType::UInt &&
type.basetype != SPIRType::Image && type.basetype != SPIRType::SampledImage &&
type.basetype != SPIRType::Sampler)
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
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();
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
{
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;
return implied_fmediump || implied_imediump ? "" : "mediump ";
}
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));
return implied_fhighp || implied_ihighp ? "" : "highp ";
}
}
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))
Use mediump on images in --vulkan-semantics as well.
2018-05-11 08:59:29 +00:00
return "mediump ";
Support mediump in desktop Vulkan GLSL.
2017-12-06 09:25:30 +00:00
else
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
else
return "";
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_precision_qualifiers_glsl(uint32_t id)
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
return flags_to_precision_qualifiers_glsl(expression_type(id), ir.meta[id].decoration.decoration_flags);
Initial commit.
2016-03-02 17:09:16 +00:00
}
string CompilerGLSL::to_qualifiers_glsl(uint32_t id)
{
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = ir.meta[id].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
string res;
auto *var = maybe_get<SPIRVariable>(id);
if (var && var->storage == StorageClassWorkgroup && !backend.shared_is_implied)
res += "shared ";
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 ";
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 ";
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
res += "writeonly ";
}
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)
{
return to_expression(var.initializer);
}
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
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
if (type.pointer_depth > 1)
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)
Add test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +00:00
res += join(" = ", to_expression(variable.static_expression));
}
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
else if (variable.initializer)
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 test for false loop init. Clean up how for loop variables are declared.
2018-01-23 20:15:09 +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
{
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = ir.meta[variable.self].decoration.decoration_flags;
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
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
SPIRType type;
type.vecsize = pls_format_to_components(var.format);
type.basetype = pls_format_to_basetype(var.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
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.
uint32_t array_size_id = type.array[index];
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
// Explicitly check for this case. The error message you would get (bad cast) makes no sense otherwise.
if (ir.ids[array_size_id].get_type() == TypeConstantOp)
SPIRV_CROSS_THROW("An array size was found to be an OpSpecConstantOp. This is not supported since "
"SPIRV-Cross cannot deduce the actual size here.");
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
uint32_t array_size = get<SPIRConstant>(array_size_id).scalar();
return array_size;
}
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());
Fix input array size in tessellation evaluation shaders.
2019-01-09 09:47:16 +00:00
// Tessellation control and evaluation shaders must have either gl_MaxPatchVertices or unsized arrays for input arrays.
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
// Opt for unsized as it's the more "correct" variant to use.
Fix input array size in tessellation evaluation shaders.
2019-01-09 09:47:16 +00:00
if (type.storage == StorageClassInput && (get_entry_point().model == ExecutionModelTessellationControl ||
get_entry_point().model == ExecutionModelTessellationEvaluation))
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
return "";
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
auto &size = type.array[index];
if (!type.array_size_literal[index])
return to_expression(size);
else if (size)
return convert_to_string(size);
else if (!backend.flexible_member_array_supported)
{
// 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 "";
}
Initial commit.
2016-03-02 17:09:16 +00:00
string CompilerGLSL::type_to_array_glsl(const SPIRType &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
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
}
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
string CompilerGLSL::image_type_glsl(const SPIRType &type, uint32_t 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 &imagetype = get<SPIRType>(type.image.type);
string res;
switch (imagetype.basetype)
{
case SPIRType::Int:
res = "i";
break;
case SPIRType::UInt:
res = "u";
break;
default:
break;
}
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" : "");
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:
res += "1D";
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)
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
require_extension_internal("GL_OES_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)) &&
image_is_comparison(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
res += "Shadow";
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)
{
Check multidimensional extension in type_to_glsl_constructor.
2017-05-22 15:47:03 +00:00
if (type.array.size() > 1)
{
if (options.flatten_multidimensional_arrays)
SPIRV_CROSS_THROW("Cannot flatten constructors of multidimensional array constructors, e.g. float[][]().");
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);
for (uint32_t i = 0; i < type.array.size(); i++)
e += "[]";
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
{
Add Clang format. Reformats the entire codebase. Better to do it now 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.
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
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())
SPIRV_CROSS_THROW("Unsigned integers are not supported on legacy 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
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;
// Reserved for temporaries.
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 (name[0] == '_' && name.size() >= 2 && isdigit(name[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
{
name.clear();
return;
}
Sanitize underscores in general, not just for members.
2018-06-04 08:13:57 +00:00
// Avoid double underscores.
name = sanitize_underscores(name);
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);
}
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);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
force_recompile = true;
}
Initial commit.
2016-03-02 17:09:16 +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
void CompilerGLSL::flatten_buffer_block(uint32_t id)
{
auto &var = get<SPIRVariable>(id);
auto &type = get<SPIRType>(var.basetype);
auto name = to_name(type.self, false);
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 &flags = ir.meta[type.self].decoration.decoration_flags;
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);
}
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)
{
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 &flags = ir.meta[var->self].decoration.decoration_flags;
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
if (flags.get(DecorationNonWritable) || 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
{
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
flags.clear(DecorationNonWritable);
flags.clear(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
force_recompile = true;
}
}
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);
decl += flags_to_precision_qualifiers_glsl(type, return_flags);
decl += type_to_glsl(type);
Support returning arrays from functions in GLSL/MSL. Not possible in HLSL apparently, need workaround ...
2018-02-05 08:34:54 +00:00
decl += type_to_array_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
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
{
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 += "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 += "(";
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
vector<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
}
}
}
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: Fix case where we pass arrays to functions by value. MSL does not support value semantics for arrays (sigh), so we need to force constant references and deal with copies if we have a different address space than what we end up guessing.
2019-01-14 09:08:35 +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);
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
if (var.storage == StorageClassWorkgroup)
{
// 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);
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;
}
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
if (var.initializer)
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)
var.deferred_declaration = 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
}
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
entry_block.loop_dominator = SPIRBlock::NoDominator;
emit_block_chain(entry_block);
end_scope();
processing_entry_point = false;
statement("");
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::emit_fixup()
{
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();
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 (execution.model == ExecutionModelVertex)
Add Clang format. Reformats the entire codebase. Better to do it now 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
}
bool CompilerGLSL::flush_phi_required(uint32_t from, uint32_t to)
{
Add Clang format. Reformats the entire codebase. Better to do it now 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);
for (auto &phi : child.phi_variables)
if (phi.parent == from)
return true;
return false;
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::flush_phi(uint32_t from, uint32_t to)
{
Add Clang format. Reformats the entire codebase. Better to do it now 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);
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 {
return future_phi.local_variable == phi.function_variable && future_phi.parent == from;
}) != 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;
force_recompile = true;
}
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
}
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
void CompilerGLSL::branch_to_continue(uint32_t from, uint32_t 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;
auto invalid = invalid_expressions;
emit_block_chain(to_block);
// Expression usage counts and invalid expressions
// are moot after returning from the continue block.
// Since we emit the same block multiple times,
// we don't want to invalidate ourselves.
expression_usage_counts = usage_counts;
invalid_expressions = invalid;
Add Clang format. Reformats the entire codebase. Better to do it now 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
}
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
else if (from_block.loop_dominator != 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)
{
auto &dominator = get<SPIRBlock>(loop_dominator);
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).
outside_control_flow = block_is_outside_flow_control_from_block(dominator, from_block);
}
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.
// Walk the CFG, if we uncoditionally execute the block calling continue assuming we're in the loop block,
// 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
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
void CompilerGLSL::branch(uint32_t from, uint32_t to)
{
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
flush_all_active_variables();
// 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
}
else if (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
{
// Very dirty workaround.
// Switch constructs are able to break, but they cannot break out of a loop at the same time.
// 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.
Add Windows support in Travis CI. - Add new Windows support - Use CMake/CTest instead of Make + shell scripts - Use --parallel in CTest - Fix CTest on Windows - Cleanups in test_shaders.py - Force specific commit for SPIRV-Headers - Fix Inf/NaN odd-ball case by moving to ASM
2018-10-26 08:53:11 +00:00
if (current_emitting_switch && is_loop_break(to) && current_emitting_switch->loop_dominator != ~0u &&
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
get<SPIRBlock>(current_emitting_switch->loop_dominator).merge_block == to)
{
if (!current_emitting_switch->need_ladder_break)
{
force_recompile = true;
current_emitting_switch->need_ladder_break = true;
}
statement("_", current_emitting_switch->self, "_ladder_break = 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
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
}
Update tests for latest SPIRV-Tools and glslang.
2018-03-12 13:58:40 +00:00
else if (is_continue(to) || (from == to))
{
// 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.
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
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
}
void CompilerGLSL::branch(uint32_t from, uint32_t cond, uint32_t true_block, uint32_t 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
// If we branch directly to a selection merge target, we don't really need a code path.
bool true_sub = !is_conditional(true_block);
bool false_sub = !is_conditional(false_block);
if (true_sub)
{
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +00:00
emit_block_hints(get<SPIRBlock>(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
statement("if (", to_expression(cond), ")");
begin_scope();
branch(from, true_block);
end_scope();
Explicitly emit break/continues in selection branches.
2018-03-09 12:59:39 +00:00
if (false_sub || is_continue(false_block) || is_break(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
{
statement("else");
begin_scope();
branch(from, false_block);
end_scope();
}
else if (flush_phi_required(from, false_block))
{
statement("else");
begin_scope();
flush_phi(from, false_block);
end_scope();
}
}
else if (false_sub && !true_sub)
{
// Only need false path, use negative conditional.
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +00:00
emit_block_hints(get<SPIRBlock>(from));
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();
Explicitly emit break/continues in selection branches.
2018-03-09 12:59:39 +00:00
if (is_continue(true_block) || is_break(true_block))
{
statement("else");
begin_scope();
branch(from, true_block);
end_scope();
}
else if (flush_phi_required(from, 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
{
statement("else");
begin_scope();
flush_phi(from, true_block);
end_scope();
}
}
Initial commit.
2016-03-02 17:09:16 +00:00
}
void CompilerGLSL::propagate_loop_dominators(const SPIRBlock &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
// Propagate down the loop dominator block, so that dominated blocks can back trace.
if (block.merge == SPIRBlock::MergeLoop || block.loop_dominator)
{
uint32_t dominator = block.merge == SPIRBlock::MergeLoop ? block.self : block.loop_dominator;
Non-functional: Update formatting.
2016-05-23 11:30:02 +00:00
auto set_dominator = [this](uint32_t self, uint32_t new_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
auto &dominated_block = this->get<SPIRBlock>(self);
// If we already have a loop dominator, we're trying to break out to merge targets
// which should not update the loop dominator.
if (!dominated_block.loop_dominator)
dominated_block.loop_dominator = new_dominator;
};
// After merging a loop, we inherit the loop dominator always.
if (block.merge_block)
set_dominator(block.merge_block, block.loop_dominator);
if (block.true_block)
set_dominator(block.true_block, dominator);
if (block.false_block)
set_dominator(block.false_block, dominator);
if (block.next_block)
set_dominator(block.next_block, dominator);
Propagate loop dominator to switch-default block This is necessary if OpSwitch is inside a loop.
2018-09-18 07:53:02 +00:00
if (block.default_block)
set_dominator(block.default_block, 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
for (auto &c : block.cases)
set_dominator(c.block, dominator);
// In older glslang output continue_block can be == loop header.
if (block.continue_block && block.continue_block != block.self)
set_dominator(block.continue_block, dominator);
}
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.
string CompilerGLSL::emit_continue_block(uint32_t 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
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;
vector<string> statements;
// 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
{
propagate_loop_dominators(*block);
// 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.
else if (block->true_block)
{
flush_phi(continue_block, block->true_block);
block = &get<SPIRBlock>(block->true_block);
}
}
// 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;
}
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.
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
bool condition_is_temporary = forced_temporaries.find(block.condition) == end(forced_temporaries);
// This can work! We only did trivial things which could be forwarded in block body!
if (current_count == statement_count && condition_is_temporary)
{
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 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)
{
auto continue_block = emit_continue_block(block.continue_block);
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:
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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("while (", to_expression(block.condition), ")");
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("For/while loop detected, but need while/for loop 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
}
begin_scope();
return true;
}
else
{
block.disable_block_optimization = true;
force_recompile = true;
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.
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
emit_block_instructions(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);
if (current_count == statement_count && condition_is_temporary)
{
propagate_loop_dominators(child);
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);
auto continue_block = emit_continue_block(block.continue_block);
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 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);
Add Clang format. Reformats the entire codebase. Better to do it now 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("while (", to_expression(child.condition), ")");
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("For/while loop detected, but need while/for loop 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
}
begin_scope();
branch(child.self, child.true_block);
return true;
}
else
{
block.disable_block_optimization = true;
force_recompile = true;
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
{
Enforce stable order for dominated phi variables.
2017-11-22 12:20:17 +00:00
// Enforce declaration order for regression testing purposes.
sort(begin(block.dominated_variables), end(block.dominated_variables));
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
}
Update glslang/SPIRV-Tools on Travis.
2018-03-24 03:16:18 +00:00
void CompilerGLSL::emit_hoisted_temporaries(vector<pair<uint32_t, uint32_t>> &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),
Need to sort declared temporaries to ensure stable output.
2018-01-29 09:22:18 +00:00
[](const pair<uint32_t, uint32_t> &a, const pair<uint32_t, uint32_t> &b) { return a.second < b.second; });
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
{
Fix name aliasing for temporary variables.
2018-03-24 00:53:08 +00:00
add_local_variable_name(tmp.second);
Fix case where OpPhi is used to swap values.
2019-01-07 10:47:01 +00:00
auto &flags = ir.meta[tmp.second].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
auto &type = get<SPIRType>(tmp.first);
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
statement(flags_to_precision_qualifiers_glsl(type, flags), variable_decl(type, to_name(tmp.second)), ";");
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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)
{
propagate_loop_dominators(block);
bool select_branch_to_true_block = false;
bool skip_direct_branch = false;
bool emitted_for_loop_header = false;
bool force_complex_continue_block = false;
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)
continue_type = continue_block_type(get<SPIRBlock>(block.continue_block));
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.
for (auto var : block.loop_variables)
get<SPIRVariable>(var).loop_variable_enable = true;
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))
{
select_branch_to_true_block = true;
emitted_for_loop_header = true;
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))
{
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
// The body of while, is actually just the true block, so always branch there unconditionally.
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
select_branch_to_true_block = true;
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
emitted_for_loop_header = 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;
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
emitted_for_loop_header = 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 (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);
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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);
Add Clang format. Reformats the entire codebase. Better to do it now 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.
if (!emitted_for_loop_header && !block.loop_variables.empty())
{
force_recompile = true;
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);
}
Add Clang format. Reformats the entire codebase. Better to do it now 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);
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
bool unsigned_case = type.basetype == SPIRType::UInt || type.basetype == SPIRType::UShort;
Add Clang format. Reformats the entire codebase. Better to do it now 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 unsigned switch case selectors.
2018-11-26 09:35:39 +00:00
if (type.basetype == SPIRType::UInt64 || type.basetype == SPIRType::Int64)
{
// 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";
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;
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
SPIRBlock *old_emitting_switch = current_emitting_switch;
current_emitting_switch = &block;
if (block.need_ladder_break)
statement("bool _", block.self, "_ladder_break = false;");
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +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("switch (", to_expression(block.condition), ")");
begin_scope();
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
// Multiple case labels can branch to same block, so find all unique blocks.
bool emitted_default = false;
unordered_set<uint32_t> emitted_blocks;
Add Clang format. Reformats the entire codebase. Better to do it now 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 &c : block.cases)
{
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
if (emitted_blocks.count(c.block) != 0)
continue;
// Emit all case labels which branch to our target.
// FIXME: O(n^2), revisit if we hit shaders with 100++ case labels ...
for (auto &other_case : block.cases)
{
if (other_case.block == c.block)
{
Fix unsigned switch case selectors.
2018-11-26 09:35:39 +00:00
// The case label value must be sign-extended properly in SPIR-V, so we can assume 32-bit values here.
Use specific base types for 8- and 16-bit integers.
2018-11-01 22:20:07 +00:00
auto case_value = unsigned_case ? convert_to_string(uint32_t(other_case.value)) :
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
convert_to_string(int32_t(other_case.value));
Fix unsigned switch case selectors.
2018-11-26 09:35:39 +00:00
statement("case ", case_value, label_suffix, ":");
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
}
}
// Maybe we share with default block?
if (block.default_block == c.block)
{
statement("default:");
emitted_default = true;
}
// Complete the target.
emitted_blocks.insert(c.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_scope();
branch(block.self, c.block);
end_scope();
}
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
if (!emitted_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
{
Deal with switch case labels which share a block.
2018-06-20 08:49:03 +00:00
if (block.default_block != block.next_block)
{
statement("default:");
begin_scope();
if (is_break(block.default_block))
SPIRV_CROSS_THROW("Cannot break; out of a switch statement and out of a loop at the same time ...");
branch(block.self, block.default_block);
end_scope();
}
else if (flush_phi_required(block.self, block.next_block))
{
statement("default:");
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
}
end_scope();
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();
}
current_emitting_switch = old_emitting_switch;
Add Clang format. Reformats the entire codebase. Better to do it now 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:
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();
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)
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
emit_array_copy("SPIRV_Cross_return_value", block.return_value);
if (!block_is_outside_flow_control_from_block(get<SPIRBlock>(current_function->entry_block), block) ||
block.loop_dominator != SPIRBlock::NoDominator)
{
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)
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
statement("return ", to_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
}
// 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 ...
else if (!block_is_outside_flow_control_from_block(get<SPIRBlock>(current_function->entry_block), block) ||
block.loop_dominator != SPIRBlock::NoDominator)
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
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;
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, ";");
Add Clang format. Reformats the entire codebase. Better to do it now 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:
emit_next_block = 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
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)
flush_phi(block.self, block.next_block);
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +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);
}
else
emit_block_chain(get<SPIRBlock>(block.next_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 (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 ...
auto statements = emit_continue_block(block.continue_block);
if (!statements.empty())
{
// The DoWhile block has side effects, force ComplexLoop pattern next pass.
get<SPIRBlock>(block.continue_block).complex_continue = true;
force_recompile = true;
}
end_scope_decl(join("while (", to_expression(get<SPIRBlock>(block.continue_block).condition), ")"));
}
else
end_scope();
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();
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
}
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
void CompilerGLSL::emit_array_copy(const string &lhs, uint32_t rhs_id)
{
statement(lhs, " = ", to_expression(rhs_id), ";");
}
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
void CompilerGLSL::bitcast_from_builtin_load(uint32_t source_id, std::string &expr,
const spirv_cross::SPIRType &expr_type)
{
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))
return;
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:
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:
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);
}
void CompilerGLSL::bitcast_to_builtin_store(uint32_t target_id, std::string &expr,
const spirv_cross::SPIRType &expr_type)
{
// 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 = expr_type.basetype;
// TODO: Fill in for more builtins.
switch (builtin)
{
case BuiltInLayer:
case BuiltInPrimitiveId:
case BuiltInViewportIndex:
expected_type = SPIRType::Int;
break;
default:
break;
}
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
void CompilerGLSL::emit_block_hints(const SPIRBlock &)
{
}
Reference in New Issue Copy Permalink