AuroraMiddleware/SPIRV-Cross
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
1ece67a050
SPIRV-Cross/spirv_glsl.hpp

691 lines
30 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.
*/
Start adding CFG analysis. Not complete yet, but partly working ...
2016-11-11 17:04:14 +00:00
#ifndef SPIRV_CROSS_GLSL_HPP
#define SPIRV_CROSS_GLSL_HPP
Initial commit.
2016-03-02 17:09:16 +00:00
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
#include "GLSL.std.450.h"
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
#include "spirv_cross.hpp"
Initial commit.
2016-03-02 17:09:16 +00:00
#include <unordered_map>
Non-functional: Update formatting.
2016-05-23 11:30:02 +00:00
#include <unordered_set>
Initial commit.
2016-03-02 17:09:16 +00:00
#include <utility>
Add an option to override the namespace used for spirv_cross. This is a pragmatic trick to avoid symbol collision where a project links against SPIRV-Cross statically, while linking to other projects which also use SPIRV-Cross statically. We can end up with very awkward symbol collisions which can resolve themselves silently because SPIRV-Cross is pulled in as necessary. To fix this, we must use different symbols and embed two copies of SPIRV-Cross in this scenario, now with different namespaces, which in turn leads to different symbols.
2019-03-29 09:29:44 +00:00
namespace SPIRV_CROSS_NAMESPACE
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
enum PlsFormat
{
PlsNone = 0,
PlsR11FG11FB10F,
PlsR32F,
PlsRG16F,
PlsRGB10A2,
PlsRGBA8,
PlsRG16,
PlsRGBA8I,
PlsRG16I,
PlsRGB10A2UI,
PlsRGBA8UI,
PlsRG16UI,
PlsR32UI
};
struct PlsRemap
{
uint32_t id;
PlsFormat format;
};
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
enum AccessChainFlagBits
{
ACCESS_CHAIN_INDEX_IS_LITERAL_BIT = 1 << 0,
ACCESS_CHAIN_CHAIN_ONLY_BIT = 1 << 1,
ACCESS_CHAIN_PTR_CHAIN_BIT = 1 << 2,
ACCESS_CHAIN_SKIP_REGISTER_EXPRESSION_READ_BIT = 1 << 3
};
typedef uint32_t AccessChainFlags;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
class CompilerGLSL : public Compiler
{
public:
struct Options
{
Add option to disable use of 420pack extension.
2017-09-08 07:56:06 +00:00
// The shading language version. Corresponds to #version $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
uint32_t version = 450;
Add option to disable use of 420pack extension.
2017-09-08 07:56:06 +00:00
// Emit the OpenGL ES shading language instead of desktop OpenGL.
Add Clang format. Reformats the entire codebase. Better to do it now 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 es = false;
Add option to disable use of 420pack extension.
2017-09-08 07:56:06 +00:00
// Debug option to always emit temporary variables for all 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
bool force_temporary = false;
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 true, Vulkan GLSL features are used instead of GL-compatible features.
// Mostly useful for debugging SPIR-V files.
bool vulkan_semantics = false;
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
// If true, gl_PerVertex is explicitly redeclared in vertex, geometry and tessellation shaders.
// The members of gl_PerVertex is determined by which built-ins are declared by the shader.
// This option is ignored in ES versions, as redeclaration in ES is not required, and it depends on a different extension
// (EXT_shader_io_blocks) which makes things a bit more fuzzy.
bool separate_shader_objects = false;
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
// Flattens multidimensional arrays, e.g. float foo[a][b][c] into single-dimensional arrays,
// e.g. float foo[a * b * c].
// This function does not change the actual SPIRType of any object.
// Only the generated code, including declarations of interface variables are changed to be single array dimension.
Add multidimensional array flattening test.
2017-05-22 15:40:00 +00:00
bool flatten_multidimensional_arrays = false;
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
Add option to disable use of 420pack extension.
2017-09-08 07:56:06 +00:00
// For older desktop GLSL targets than version 420, the
// GL_ARB_shading_language_420pack extensions is used to be able to support
// layout(binding) on UBOs and samplers.
// If disabled on older targets, binding decorations will be stripped.
bool enable_420pack_extension = true;
GLSL: Support emitting push constant block as a plain UBO.
2019-03-19 09:58:37 +00:00
// In non-Vulkan GLSL, emit push constant blocks as UBOs rather than plain uniforms.
bool emit_push_constant_as_uniform_buffer = false;
GLSL: Add option to disable buffer blocks regardless of version
2019-05-11 14:30:33 +00:00
// Always emit uniform blocks as plain uniforms, regardless of the GLSL version, even when UBOs are supported.
// Does not apply to shader storage or push constant blocks.
bool emit_uniform_buffer_as_plain_uniforms = false;
Support emitting OpLine directive. Facilitates easier mapping from source language to cross-compiled output in tooling.
2019-05-28 11:41:46 +00:00
// Emit OpLine directives if present in the module.
// May not correspond exactly to original source, but should be a good approximation.
Fix erronous default for emit_line_directives.
2019-06-02 14:20:21 +00:00
bool emit_line_directives = false;
Support emitting OpLine directive. Facilitates easier mapping from source language to cross-compiled output in tooling.
2019-05-28 11:41: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
enum Precision
{
DontCare,
Lowp,
Mediump,
Highp
};
struct
{
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
// GLSL: In vertex shaders, rewrite [0, w] depth (Vulkan/D3D style) to [-w, w] depth (GL style).
// MSL: In vertex shaders, rewrite [-w, w] depth (GL style) to [0, w] depth.
// HLSL: In vertex shaders, rewrite [-w, w] depth (GL style) to [0, w] depth.
bool fixup_clipspace = false;
// Inverts gl_Position.y or equivalent.
bool flip_vert_y = false;
Add support to remove SPIRV_Cross_BaseInstance uniform.
2018-06-22 08:01:38 +00:00
HLSL: Support BaseVertex/BaseInstance offsets. Opt-in, since user need to know about a cbuffer. Conflicts a bit with the GLSL option for base instance, since that one is enabled by default, but the HLSL one isn't (because user needs to know about a magic cbuffer, whereas GLSL can only get default initialized uniform).
2019-01-11 09:32:14 +00:00
// GLSL only, for HLSL version of this option, see CompilerHLSL.
Add support to remove SPIRV_Cross_BaseInstance uniform.
2018-06-22 08:01:38 +00:00
// If true, the backend will assume that InstanceIndex will need to apply
// a base instance offset. Set to false if you know you will never use base instance
// functionality as it might remove some internal uniforms.
bool support_nonzero_base_instance = 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
} vertex;
struct
{
// Add precision mediump float in ES targets when emitting GLES source.
// Add precision highp int in ES targets when emitting GLES source.
Precision default_float_precision = Mediump;
Precision default_int_precision = Highp;
} fragment;
};
Do not use SmallVector as input type in public interfaces. This is an API break, which we need to be careful with. Handing out SmallVectors is easier since the interface is basically the same.
2019-04-09 10:46:23 +00:00
void remap_pixel_local_storage(std::vector<PlsRemap> inputs, std::vector<PlsRemap> 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
{
pls_inputs = std::move(inputs);
pls_outputs = std::move(outputs);
remap_pls_variables();
}
Do not use SmallVector as input type in public interfaces. This is an API break, which we need to be careful with. Handing out SmallVectors is easier since the interface is basically the same.
2019-04-09 10:46:23 +00:00
explicit CompilerGLSL(std::vector<uint32_t> spirv_)
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
: Compiler(std::move(spirv_))
Add Clang format. Reformats the entire codebase. Better to do it now 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 vector-less IR construction to subclasses as well.
2017-04-01 14:08:19 +00:00
init();
}
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
CompilerGLSL(const uint32_t *ir_, size_t word_count)
: Compiler(ir_, word_count)
{
init();
}
explicit CompilerGLSL(const ParsedIR &ir_)
: Compiler(ir_)
{
init();
}
explicit CompilerGLSL(ParsedIR &&ir_)
: Compiler(std::move(ir_))
Add vector-less IR construction to subclasses as well.
2017-04-01 14:08:19 +00:00
{
init();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
Deprecate set_options()/get_options() interface, replace it. Replace with common/hlsl/msl instead. The old interface had some bad interaction with overloading which meant you had to up-cast to base class to be able to use set_options, which was awkward.
2018-03-09 14:25:25 +00:00
const Options &get_common_options() const
{
return options;
}
void set_common_options(const Options &opts)
{
options = opts;
}
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
std::string compile() override;
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
// Returns the current string held in the conversion buffer. Useful for
// capturing what has been converted so far when compile() throws an error.
std::string get_partial_source();
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
// Adds a line to be added right after #version in GLSL backend.
// This is useful for enabling custom extensions which are outside the scope of SPIRV-Cross.
// This can be combined with variable remapping.
// A new-line will be added.
//
// While add_header_line() is a more generic way of adding arbitrary text to the header
// of a GLSL file, require_extension() should be used when adding extensions since it will
// avoid creating collisions with SPIRV-Cross generated extensions.
//
// Code added via add_header_line() is typically backend-specific.
void add_header_line(const std::string &str);
// Adds an extension which is required to run this shader, e.g.
// require_extension("GL_KHR_my_extension");
void require_extension(const std::string &ext);
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
// Legacy GLSL compatibility method.
Add flattening support for push constants.
2017-01-21 09:27:14 +00:00
// Takes a uniform or push constant variable and flattens it into a (i|u)vec4 array[N]; array instead.
// For this to work, all types in the block must be the same basic type, e.g. mixing vec2 and vec4 is fine, but
// mixing int and float is not.
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
// The name of the uniform array will be the same as the interface block name.
void flatten_buffer_block(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
protected:
void reset();
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
void emit_function(SPIRFunction &func, const Bitset &return_flags);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
bool has_extension(const std::string &ext) const;
Decouple public require_extension and the internal use of the function.
2018-04-05 12:42:52 +00:00
void require_extension_internal(const std::string &ext);
Fixups for PR #338 review.
2017-11-22 18:27:03 +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
// Virtualize methods which need to be overridden by subclass targets like C++ and such.
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
virtual void emit_function_prototype(SPIRFunction &func, const Bitset &return_flags);
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
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
SPIRBlock *current_emitting_block = nullptr;
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 *current_emitting_switch = nullptr;
Deal with switch block fallthrough more correctly ...
2019-06-20 10:14:19 +00:00
bool current_emitting_switch_fallthrough = false;
Add GroupSync() in HLSL.
2017-10-20 14:18:02 +00:00
Support MSL-specific functions. Add CompilerMSL emit_instruction() and emit_glsl_op() functions to handle MSL-specific operation and function definitions. Remove CompilerMSL emit_msl_defines() function.
2016-10-27 22:47:17 +00:00
virtual void emit_instruction(const Instruction &instr);
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 emit_block_instructions(SPIRBlock &block);
Run format.sh.
2016-11-12 09:04:50 +00:00
virtual void emit_glsl_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args,
uint32_t count);
Fixups for PR #338 review.
2017-11-22 18:27:03 +00:00
virtual void emit_spv_amd_shader_ballot_op(uint32_t result_type, uint32_t result_id, uint32_t op,
const uint32_t *args, uint32_t count);
virtual void emit_spv_amd_shader_explicit_vertex_parameter_op(uint32_t result_type, uint32_t result_id, uint32_t op,
const uint32_t *args, uint32_t count);
virtual void emit_spv_amd_shader_trinary_minmax_op(uint32_t result_type, uint32_t result_id, uint32_t op,
const uint32_t *args, uint32_t count);
Add support for new extensions.
2017-11-21 13:04:57 +00:00
virtual void emit_spv_amd_gcn_shader_op(uint32_t result_type, uint32_t result_id, uint32_t op, const uint32_t *args,
uint32_t 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
virtual void emit_header();
Support emitting OpLine directive. Facilitates easier mapping from source language to cross-compiled output in tooling.
2019-05-28 11:41:46 +00:00
void emit_line_directive(uint32_t file_id, uint32_t line_literal);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
void build_workgroup_size(SmallVector<std::string> &arguments, const SpecializationConstant &x,
Run format_all.sh.
2018-11-01 10:23:33 +00:00
const SpecializationConstant &y, const SpecializationConstant &z);
Support macro overrides for spec constants in HLSL.
2018-11-01 09:53: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
virtual void emit_sampled_image_op(uint32_t result_type, uint32_t result_id, uint32_t image_id, uint32_t samp_id);
virtual void emit_texture_op(const Instruction &i);
Start adding Vulkan 1.1 subgroup support to GLSL.
2018-04-10 14:13:33 +00:00
virtual void emit_subgroup_op(const Instruction &i);
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
virtual std::string type_to_glsl(const SPIRType &type, uint32_t id = 0);
Add support for SampleId/SampleMask/SamplePosition builtins.
2017-07-24 08:07:02 +00:00
virtual std::string builtin_to_glsl(spv::BuiltIn builtin, spv::StorageClass storage);
Updates to MSL functionality to support PR review feedback.
2017-03-11 17:17:22 +00:00
virtual void 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 std::string &qualifier = "", uint32_t base_offset = 0);
Tests run clean.
2019-07-22 08:23:39 +00:00
virtual void emit_struct_padding_target(const SPIRType &type);
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
virtual std::string image_type_glsl(const SPIRType &type, uint32_t id = 0);
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
std::string constant_expression(const SPIRConstant &c);
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
std::string constant_op_expression(const SPIRConstantOp &cop);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
virtual std::string constant_expression_vector(const SPIRConstant &c, uint32_t vector);
virtual void emit_fixup();
Avoid ugly workaround for separate shadow samplers in GLSL/HLSL.
2017-06-17 08:54:59 +00:00
virtual std::string variable_decl(const SPIRType &type, const std::string &name, uint32_t id = 0);
Run clang-format.
2016-10-24 13:24:24 +00:00
virtual std::string to_func_call_arg(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
virtual std::string to_function_name(uint32_t img, const SPIRType &imgtype, bool is_fetch, bool is_gather,
bool is_proj, bool has_array_offsets, bool has_offset, bool has_grad,
MSL: Support MinLod operand.
2019-06-11 09:10:16 +00:00
bool has_dref, uint32_t lod, uint32_t minlod);
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
virtual std::string 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,
Run format_all.sh.
2019-06-21 14:02:22 +00:00
uint32_t minlod, bool *p_forward);
Convert uniform buffer blocks to cbuffers
2017-01-24 08:17:43 +00:00
virtual void emit_buffer_block(const SPIRVariable &type);
virtual void emit_push_constant_block(const SPIRVariable &var);
Do not output layouts for uniforms in HLSL
2017-01-24 08:23:22 +00:00
virtual void emit_uniform(const SPIRVariable &var);
Run format_all.sh.
2019-07-23 10:23:41 +00:00
virtual std::string unpack_expression_type(std::string expr_str, const SPIRType &type, uint32_t physical_type_id,
Pass down row-major state to unpacking functions.
2019-07-19 11:03:08 +00:00
bool packed_type, bool row_major);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
StringStream<> 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
template <typename T>
inline void statement_inner(T &&t)
{
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
buffer << std::forward<T>(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
statement_count++;
}
template <typename T, typename... Ts>
inline void statement_inner(T &&t, Ts &&... ts)
{
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
buffer << std::forward<T>(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
statement_count++;
statement_inner(std::forward<Ts>(ts)...);
}
template <typename... Ts>
inline void statement(Ts &&... ts)
{
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
if (is_forcing_recompilation())
Handle exponential explosion of code-gen during first phase of compile. Certain patterns with OpVectorShuffle (and probably others) will cascade to so large, that they can cause OOM. After we have observed force_recompile, don't spend unnecessary memory emitting code which will never be used.
2018-01-15 09:26:12 +00:00
{
// Do not bother emitting code while force_recompile is active.
// We will compile again.
statement_count++;
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 (redirect_statement)
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
{
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
Detect invalid DoWhileLoop early. We had a bug where error conditions in DoWhileLoop emit path would not detect that statements were being emitted due to the masking behavior which happens when force_recompile is true. Fix this. Also, refactor force_recompile into member functions so we can properly break on any situation where this is set, without having to rely on watchpoints in debuggers.
2019-04-05 10:06:10 +00:00
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
else
{
More cleanup
2018-06-19 15:14:31 +00:00
for (uint32_t i = 0; i < indent; i++)
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
buffer << " ";
Add Clang format. Reformats the entire codebase. Better to do it now 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_inner(std::forward<Ts>(ts)...);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
buffer << '\n';
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
}
}
template <typename... Ts>
inline void statement_no_indent(Ts &&... ts)
{
auto old_indent = indent;
indent = 0;
statement(std::forward<Ts>(ts)...);
indent = old_indent;
}
// Used for implementing continue blocks where
// we want to obtain a list of statements we can merge
// on a single line separated by comma.
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<std::string> *redirect_statement = 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
const SPIRBlock *current_continue_block = nullptr;
void begin_scope();
void end_scope();
void end_scope_decl();
void end_scope_decl(const std::string &decl);
Options options;
std::string type_to_array_glsl(const SPIRType &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
std::string to_array_size(const SPIRType &type, uint32_t index);
uint32_t to_array_size_literal(const SPIRType &type, uint32_t index) const;
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 to_array_size_literal(const SPIRType &type) const;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
std::string variable_decl(const SPIRVariable &variable);
Do not emit storage qualifiers for local variables. Metal backend uses local variables to implement global variables. Do not emit storage qualifiers for any variable which is declared inside a function.
2017-02-24 10:15:34 +00:00
std::string variable_decl_function_local(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
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 add_local_variable_name(uint32_t id);
void add_resource_name(uint32_t id);
void add_member_name(SPIRType &type, uint32_t name);
Handle overloaded functions which share the same OpName. Awkward, but legal SPIR-V.
2018-02-23 13:13:46 +00:00
void add_function_overload(const SPIRFunction &func);
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
CompilerMSL support conversion of non-square row-major matrices.
2018-01-04 21:33:45 +00:00
virtual bool is_non_native_row_major_matrix(uint32_t id);
virtual bool member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index);
Run format_all.sh.
2019-07-23 10:23:41 +00:00
bool member_is_remapped_physical_type(const SPIRType &type, uint32_t index) const;
bool member_is_packed_physical_type(const SPIRType &type, uint32_t index) const;
virtual std::string convert_row_major_matrix(std::string exp_str, const SPIRType &exp_type,
uint32_t physical_type_id, 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
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
std::unordered_set<std::string> local_variable_names;
std::unordered_set<std::string> resource_names;
GLSL: Allow blocks to have their own namespace.
2018-08-21 09:29:08 +00:00
std::unordered_set<std::string> block_input_names;
std::unordered_set<std::string> block_output_names;
std::unordered_set<std::string> block_ubo_names;
std::unordered_set<std::string> block_ssbo_names;
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
std::unordered_set<std::string> block_names; // A union of all block_*_names.
Handle overloaded functions which share the same OpName. Awkward, but legal SPIR-V.
2018-02-23 13:13:46 +00:00
std::unordered_map<std::string, std::unordered_set<uint64_t>> function_overloads;
GLSL: Fix block name shenanigans in edge cases. When we force recompile, the old var.self name we used as a fallback name might have been disturbed, so we should recover certain names back to their original form in case we are forced to take a recompile to make the naming algorithm more deterministic.
2019-02-13 15:39:59 +00:00
std::unordered_map<uint32_t, std::string> preserved_aliases;
void preserve_alias_on_reset(uint32_t id);
void reset_name_caches();
Add Clang format. Reformats the entire codebase. Better to do it now 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 processing_entry_point = false;
// Can be overriden by subclass backends for trivial things which
// shouldn't need polymorphism.
struct BackendVariations
{
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
std::string discard_literal = "discard";
Support the SPV_EXT_demote_to_helper_invocation extension. This extension provides a new operation which causes a fragment to be discarded without terminating the fragment shader invocation. The invocation for the discarded fragment becomes a helper invocation, so that derivatives will remain defined. The old `HelperInvocation` builtin becomes undefined when this occurs, so a second new instruction queries the current helper invocation status. This is only fully supported for GLSL. HLSL doesn't support the `IsHelperInvocation` operation and MSL doesn't support the `DemoteToHelperInvocation` op. Fixes #1052.
2019-07-13 20:57:33 +00:00
std::string demote_literal = "demote";
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::string null_pointer_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
bool float_literal_suffix = false;
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
bool double_literal_suffix = 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
bool uint32_t_literal_suffix = true;
Add support for int64/uint64 in GLSL.
2016-07-27 09:27:00 +00:00
bool long_long_literal_suffix = 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 char *basic_int_type = "int";
const char *basic_uint_type = "uint";
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
const char *basic_int8_type = "int8_t";
const char *basic_uint8_type = "uint8_t";
const char *basic_int16_type = "int16_t";
const char *basic_uint16_type = "uint16_t";
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
const char *int16_t_literal_suffix = "s";
const char *uint16_t_literal_suffix = "us";
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
const char *nonuniform_qualifier = "nonuniformEXT";
MSL: Use the select() function for OpSelect. This significantly improves codegen for vector `OpSelect` in MSL.
2019-07-11 04:46:40 +00:00
const char *boolean_mix_function = "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
bool swizzle_is_function = false;
bool shared_is_implied = false;
HLSL/MSL: Deal correctly with nonuniformEXT qualifier. MSL does not seem to have a qualifier for this, but HLSL SM 5.1 does. glslangValidator for HLSL does not support this, so skip any validation, but it passes in FXC.
2019-05-13 12:58:27 +00:00
bool unsized_array_supported = true;
Deal better with OpName and OpMemberName which alias. OpName is only for debug information, so we must be very careful that we do not reuse the same name for different variables. This was previously done for local variables, but this commit extends this to global variables as well.
2016-05-23 10:25:09 +00:00
bool explicit_struct_type = false;
Use std::array in C++ backend. Deals better with composite construction in C++ and also fixes a few bugs in GLSL backend with array-of-arrays.
2016-05-28 11:09:26 +00:00
bool use_initializer_list = false;
Fix HLSL regression with struct declaration. It actually worked surprisingly. Fix it properly.
2018-01-23 15:36:20 +00:00
bool use_typed_initializer_list = false;
bool can_declare_struct_inline = true;
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
bool can_declare_arrays_inline = true;
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 native_row_major_matrix = true;
Do not splat type contructor arguments in HLSL
2016-09-23 16:57:18 +00:00
bool use_constructor_splatting = true;
Support mediump in desktop Vulkan GLSL.
2017-12-06 09:25:30 +00:00
bool allow_precision_qualifiers = false;
Fix compatibility with FXC.
2017-12-12 10:03:46 +00:00
bool can_swizzle_scalar = false;
Opt in to gl_in/gl_out handling rather than other way around.
2018-01-09 08:16:33 +00:00
bool force_gl_in_out_block = false;
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
bool can_return_array = true;
CompilerMSL support gl_SampleMask and convert it to scalar uint from array.
2018-02-13 19:44:40 +00:00
bool allow_truncated_access_chain = false;
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
bool supports_extensions = false;
Support empty structs. Need to fake it by pretending it has one dummy member.
2018-04-05 14:26:54 +00:00
bool supports_empty_struct = false;
MSL: Support array-of-arrays composite construction.
2018-09-12 08:25:51 +00:00
bool array_is_value_type = true;
MSL: Fix textures which are sampled and compared against. depth2d in MSL only returns float, not float4, even for normal sampling. We need to conditionally remap-swizzle back to float4.
2019-02-22 11:02:11 +00:00
bool comparison_image_samples_scalar = false;
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
bool native_pointers = false;
Handle more cases with FP16 and texture sampling.
2019-06-27 13:04:22 +00:00
bool support_small_type_sampling_result = false;
HLSL: Does not support case-fallthrough. Disable any fallthrough on HLSL. Risky business if fallthrough blocks had a barrier(), but can't do anything about that ...
2019-06-27 13:10:17 +00:00
bool support_case_fallthrough = 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
} backend;
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 emit_struct(SPIRType &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
void emit_resources();
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 emit_buffer_block_native(const SPIRVariable &var);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
void emit_buffer_reference_block(SPIRType &type, bool forward_declaration);
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 emit_buffer_block_legacy(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
void emit_buffer_block_flattened(const SPIRVariable &type);
Add separate shader object support. Allow redeclaring gl_PerVertex for stage compatibility.
2017-05-22 13:30:43 +00:00
void emit_declared_builtin_block(spv::StorageClass storage, spv::ExecutionModel model);
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
void emit_push_constant_block_vulkan(const SPIRVariable &var);
void emit_push_constant_block_glsl(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
void emit_interface_block(const SPIRVariable &type);
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 emit_flattened_io_block(const SPIRVariable &var, const char *qual);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
void emit_block_chain(SPIRBlock &block);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
void emit_hoisted_temporaries(SmallVector<std::pair<uint32_t, uint32_t>> &temporaries);
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
std::string constant_value_macro_name(uint32_t id);
Deduce constant LUTs from read-write variables.
2018-07-05 11:25:57 +00:00
void emit_constant(const SPIRConstant &constant);
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 emit_specialization_constant_op(const SPIRConstantOp &constant);
Support do-while where test is negative.
2019-03-06 11:17:38 +00:00
std::string emit_continue_block(uint32_t continue_block, bool follow_true_block, bool follow_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
bool attempt_emit_loop_header(SPIRBlock &block, SPIRBlock::Method method);
void branch(uint32_t from, uint32_t to);
Handle cases where merge selects as also loop merge or continue blocks.
2018-03-08 13:01:10 +00:00
void branch_to_continue(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
void branch(uint32_t from, uint32_t cond, uint32_t true_block, uint32_t false_block);
void flush_phi(uint32_t from, uint32_t to);
bool flush_phi_required(uint32_t from, uint32_t to);
void flush_variable_declaration(uint32_t id);
Start adding CFG analysis. Not complete yet, but partly working ...
2016-11-11 17:04:14 +00:00
void flush_undeclared_variables(SPIRBlock &block);
Fix declaration of loop variables with a Phi helper copy. Certain Phi variables need to maintain a temporary copy, but we forgot to declare them when the master variable is a loop variable itself.
2019-06-25 08:45:15 +00:00
void emit_variable_temporary_copies(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
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 should_dereference(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
bool should_forward(uint32_t id);
void emit_mix_op(uint32_t result_type, uint32_t id, uint32_t left, uint32_t right, uint32_t lerp);
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
void emit_nminmax_op(uint32_t result_type, uint32_t id, uint32_t op0, uint32_t op1, GLSLstd450 op);
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 to_trivial_mix_op(const SPIRType &type, std::string &op, uint32_t left, uint32_t right, uint32_t 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
void 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);
void emit_trinary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2,
const char *op);
void emit_binary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op);
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
void emit_unary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op,
SPIRType::BaseType input_type, SPIRType::BaseType expected_result_type);
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 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);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
void emit_trinary_func_op_cast(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, uint32_t op2,
const char *op, SPIRType::BaseType input_type);
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
Add Clang format. Reformats the entire codebase. Better to do it now 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 emit_unary_func_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op);
Fix OpLogicalNot in HLSL
2017-03-24 14:00:48 +00:00
void emit_unrolled_unary_op(uint32_t result_type, uint32_t result_id, uint32_t operand, const char *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
void emit_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op);
Handle vector variants of OpLogicalAnd/Or/Not.
2017-03-20 21:38:05 +00:00
void emit_unrolled_binary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, uint32_t op1, const char *op);
Implement more correct integer op handling. In some cases we need to bitcast when dealing with int vs. uint. SPIR-V allows inputs to be of different integer signedness, so we need to deal with this somehow. Add testing system to test SPIR-V assembly. For now, test all possible combination for all major cases. - IAdd (which doesn't care about input type as long as they're equal) - SDiv/UDiv operations which case about input type. - Arith/Logical right shifts. - IEqual to test outputs to bvec, which shouldn't get output cast. Also tests casting in function-like calls.
2016-05-10 21:39:41 +00:00
void 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);
SPIRType binary_op_bitcast_helper(std::string &cast_op0, std::string &cast_op1, SPIRType::BaseType &input_type,
uint32_t op0, uint32_t op1, bool skip_cast_if_equal_type);
Support ternary expressions in OpSpecConstantOp.
2018-06-25 07:48:17 +00:00
std::string to_ternary_expression(const SPIRType &result_type, uint32_t select, uint32_t true_value,
uint32_t false_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
void emit_unary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op);
bool expression_is_forwarded(uint32_t id);
SPIRExpression &emit_op(uint32_t result_type, uint32_t result_id, const std::string &rhs, bool forward_rhs,
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 = false);
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
Run format_all.sh.
2019-01-17 10:29:50 +00:00
std::string access_chain_internal(uint32_t base, const uint32_t *indices, uint32_t count, AccessChainFlags flags,
AccessChainMeta *meta);
Refactor access_chain_internal to be more readable from callsite.
2019-01-17 09:30:13 +00:00
Run style formatter.
2017-01-20 16:33:59 +00:00
std::string 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 = nullptr, bool ptr_chain = false);
Run style formatter.
2017-01-20 16:33:59 +00:00
std::string flattened_access_chain(uint32_t base, const uint32_t *indices, uint32_t count,
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
const SPIRType &target_type, uint32_t offset, uint32_t matrix_stride,
bool need_transpose);
Run style formatter.
2017-01-20 16:33:59 +00:00
std::string flattened_access_chain_struct(uint32_t base, const uint32_t *indices, uint32_t count,
const SPIRType &target_type, uint32_t offset);
std::string 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 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 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);
Begin implementing ByteAddressBuffer flattening for HLSL.
2017-08-10 13:36:30 +00:00
std::pair<std::string, uint32_t> flattened_access_chain_offset(const SPIRType &basetype, const uint32_t *indices,
Run style formatter.
2017-01-20 16:33:59 +00:00
uint32_t count, uint32_t offset,
Run format_all.sh.
2017-08-28 07:01:03 +00:00
uint32_t word_stride, bool *need_transpose = nullptr,
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
uint32_t *matrix_stride = nullptr,
bool ptr_chain = 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 char *index_to_swizzle(uint32_t index);
Use remap_swizzle for image load-store more actively.
2017-10-24 07:23:29 +00:00
std::string remap_swizzle(const SPIRType &result_type, uint32_t input_components, const std::string &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
std::string declare_temporary(uint32_t type, uint32_t id);
MSL: Fix OpLoad of array which is forced to a temporary.
2019-04-09 09:50:45 +00:00
void emit_uninitialized_temporary(uint32_t type, uint32_t id);
SPIRExpression &emit_uninitialized_temporary_expression(uint32_t type, uint32_t id);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
void append_global_func_args(const SPIRFunction &func, uint32_t index, SmallVector<std::string> &arglist);
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
std::string to_expression(uint32_t id, bool register_expression_read = true);
MSL: Re-roll array expressions in initializers. We cannot rely on copy path when using an array as part of a struct initializer, so reroll such expressions to an initializer list again.
2019-07-10 09:19:33 +00:00
std::string to_composite_constructor_expression(uint32_t id);
std::string to_rerolled_array_expression(const std::string &expr, const SPIRType &type);
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
std::string to_enclosed_expression(uint32_t id, bool register_expression_read = true);
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
std::string to_unpacked_expression(uint32_t id, bool register_expression_read = true);
Use to_unpacked_row_major_expression to unify row-major in MSL/GLSL.
2019-07-23 09:36:54 +00:00
std::string to_unpacked_row_major_matrix_expression(uint32_t 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
std::string to_enclosed_unpacked_expression(uint32_t id, bool register_expression_read = true);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
std::string to_dereferenced_expression(uint32_t id, bool register_expression_read = true);
Deal with packing/unpacking on store. Still a bit buggy, since we cannot deduce between float2[] and packed_float2. Need a deeper refactor to plumb this through ...
2019-01-17 09:06:23 +00:00
std::string to_pointer_expression(uint32_t id, bool register_expression_read = true);
std::string to_enclosed_pointer_expression(uint32_t id, bool register_expression_read = true);
Deal with packed expressions in more scenarios. Make a new "to_extract_component_expression" helper.
2018-05-25 08:56:27 +00:00
std::string to_extract_component_expression(uint32_t id, uint32_t index);
Add support for flattening multidimensional arrays.
2017-05-22 14:52:25 +00:00
std::string enclose_expression(const std::string &expr);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
std::string dereference_expression(const SPIRType &expression_type, const std::string &expr);
MSL: Support SPV_KHR_variable_pointers. This allows shaders to declare and use pointer-type variables. Pointers may be loaded and stored, be the result of an `OpSelect`, be passed to and returned from functions, and even be passed as inputs to the `OpPhi` instruction. All types of pointers may be used as variable pointers. Variable pointers to storage buffers and workgroup memory may even be loaded from and stored to, as though they were ordinary variables. In addition, this enables using an interior pointer to an array as though it were an array pointer itself using the `OpPtrAccessChain` instruction. This is a rather large and involved change, mostly because this is somewhat complicated with a lot of moving parts. It's a wonder SPIRV-Cross's output is largely unchanged. Indeed, many of these changes are to accomplish exactly that! Perhaps the largest source of changes was the violation of the assumption that, when emitting types, the pointer type didn't matter. One of the test cases added by the change doesn't optimize very well; the output of `spirv-opt` here is invalid SPIR-V. I need to file a bug with SPIRV-Tools about this. I wanted to test that variable pointers to images worked too, but I couldn't figure out how to propagate the access qualifier properly--in MSL, it's part of the type, so getting this right is important. I've punted on that for now.
2018-12-03 08:06:33 +00:00
std::string address_of_expression(const std::string &expr);
Fixes for MSL and strip redundant parens in some places.
2016-12-06 22:03:35 +00:00
void strip_enclosed_expression(std::string &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
std::string to_member_name(const SPIRType &type, uint32_t index);
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
virtual std::string to_member_reference(uint32_t base, const SPIRType &type, uint32_t index, bool 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
std::string type_to_glsl_constructor(const SPIRType &type);
std::string argument_decl(const SPIRFunction::Parameter &arg);
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
virtual std::string to_qualifiers_glsl(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
const char *to_precision_qualifiers_glsl(uint32_t id);
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
virtual const char *to_storage_qualifiers_glsl(const SPIRVariable &var);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
const char *flags_to_qualifiers_glsl(const SPIRType &type, const Bitset &flags);
More cleanup
2018-06-19 15:14:31 +00:00
const char *format_to_glsl(spv::ImageFormat format);
Handle I/O blocks separately from regular inputs and outputs.
2017-03-07 15:18:43 +00:00
virtual std::string layout_for_member(const SPIRType &type, uint32_t index);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
virtual std::string to_interpolation_qualifiers(const Bitset &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
std::string layout_for_variable(const SPIRVariable &variable);
Declare shadow arguments.
2016-09-11 10:54:08 +00:00
std::string to_combined_image_sampler(uint32_t image_id, uint32_t samp_id);
Fix separate sampler images in MSL.
2017-05-07 10:36:14 +00:00
virtual bool skip_argument(uint32_t id) const;
Return arrays in HLSL/MSL by writing to an output variable instead.
2018-02-05 11:37:41 +00:00
virtual void emit_array_copy(const std::string &lhs, uint32_t rhs_id);
Support branch/loop hints in HLSL.
2018-06-25 08:33:13 +00:00
virtual void emit_block_hints(const SPIRBlock &block);
Deal with composite constants in variable initializer.
2018-07-05 13:29:49 +00:00
virtual std::string to_initializer_expression(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
hlsl: Support custom root constant layout
2017-11-27 15:00:56 +00:00
bool buffer_is_packing_standard(const SPIRType &type, BufferPackingStandard packing, uint32_t start_offset = 0,
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
uint32_t end_offset = ~(0u));
GLSL: Support std430 in UBOs with scalar layout.
2019-05-28 10:21:08 +00:00
std::string buffer_to_packing_standard(const SPIRType &type, bool support_std430_without_scalar_layout);
GLSL: Implement GL_EXT_buffer_reference. Buffer objects can contain arbitrary pointers to blocks. We can also implement ConvertPtrToU and ConvertUToPtr. The latter can cast a uint64_t to any type as it pleases, so we will need to generate fake buffer reference blocks to be able to cast the type.
2019-04-24 12:12:50 +00:00
Validate that std140 packing can actually be used.
2017-10-10 08:12:27 +00:00
uint32_t type_to_packed_base_size(const SPIRType &type, BufferPackingStandard packing);
Rewrite everything to use Bitset rather than uint64_t.
2018-03-12 12:09:25 +00:00
uint32_t type_to_packed_alignment(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing);
uint32_t type_to_packed_array_stride(const SPIRType &type, const Bitset &flags, BufferPackingStandard packing);
uint32_t type_to_packed_size(const SPIRType &type, const Bitset &flags, BufferPackingStandard 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
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
std::string bitcast_glsl(const SPIRType &result_type, uint32_t arg);
Add bit casting to HLSL
2017-03-24 13:13:59 +00:00
virtual std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_type);
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
std::string bitcast_expression(SPIRType::BaseType target_type, uint32_t arg);
Run format_all.sh.
2017-09-19 14:09:19 +00:00
std::string bitcast_expression(const SPIRType &target_type, SPIRType::BaseType expr_type, const std::string &expr);
Various fixes to texture/image query in GLSL.
2017-09-19 14:08:25 +00:00
Do not merge swizzles for anything other than vectors.
2018-01-22 08:52:57 +00:00
std::string build_composite_combiner(uint32_t result_type, const uint32_t *elems, uint32_t length);
Add Clang format. Reformats the entire codebase. Better to do it now 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 remove_duplicate_swizzle(std::string &op);
bool remove_unity_swizzle(uint32_t base, std::string &op);
// Can modify flags to remote readonly/writeonly if image type
// and force recompile.
bool check_atomic_image(uint32_t id);
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
virtual void replace_illegal_names();
Add support for constexpr samplers in MSL.
2018-04-17 15:43:10 +00:00
virtual void 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
Add Clang format. Reformats the entire codebase. Better to do it now 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 replace_fragment_output(SPIRVariable &var);
void replace_fragment_outputs();
Throw when an lod value is used but not supported Plus requested changes.
2017-03-23 13:43:54 +00:00
bool check_explicit_lod_allowed(uint32_t lod);
Support OpTypeImage with depth == 2 (unknown) properly. Track which OpSampledImages are ever used with Dref opcodes.
2018-07-04 12:25:10 +00:00
std::string legacy_tex_op(const std::string &op, const SPIRType &imgtype, uint32_t lod, 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
uint32_t indent = 0;
std::unordered_set<uint32_t> emitted_functions;
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
std::unordered_set<uint32_t> flattened_buffer_blocks;
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
std::unordered_set<uint32_t> flattened_structs;
Add support for loading flattened structs.
2017-02-23 18:24:59 +00:00
std::string load_flattened_struct(SPIRVariable &var);
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
std::string to_flattened_struct_member(const SPIRVariable &var, uint32_t index);
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
void store_flattened_struct(SPIRVariable &var, uint32_t value);
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 Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
// Usage tracking. If a temporary is used more than once, use the temporary instead to
// avoid AST explosion when SPIRV is generated with pure SSA and doesn't write stuff to variables.
std::unordered_map<uint32_t, uint32_t> expression_usage_counts;
void track_expression_read(uint32_t id);
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
SmallVector<std::string> forced_extensions;
SmallVector<std::string> header_lines;
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
GLSL/HLSL: Implement NMin/NMax/NClamp. Need to emulate these calls for correctness.
2019-03-21 14:26:46 +00:00
// Used when expressions emit extra opcodes with their own unique IDs,
// and we need to reuse the IDs across recompilation loops.
// Currently used by NMin/Max/Clamp implementations.
std::unordered_map<uint32_t, uint32_t> extra_sub_expressions;
Do not use SmallVector as input type in public interfaces. This is an API break, which we need to be careful with. Handing out SmallVectors is easier since the interface is basically the same.
2019-04-09 10:46:23 +00:00
uint32_t statement_count = 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
inline bool is_legacy() const
{
return (options.es && options.version < 300) || (!options.es && options.version < 130);
}
Legacy GLES extensions.
2016-09-17 12:33:16 +00:00
inline bool is_legacy_es() const
{
Clean up.
2016-09-17 13:56:23 +00:00
return options.es && options.version < 300;
}
inline bool is_legacy_desktop() const
{
return !options.es && options.version < 130;
Legacy GLES extensions.
2016-09-17 12:33: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
bool args_will_forward(uint32_t id, const uint32_t *args, uint32_t num_args, bool pure);
void register_call_out_argument(uint32_t id);
void register_impure_function_call();
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 register_control_dependent_expression(uint32_t 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
// GL_EXT_shader_pixel_local_storage support.
Do not use SmallVector as input type in public interfaces. This is an API break, which we need to be careful with. Handing out SmallVectors is easier since the interface is basically the same.
2019-04-09 10:46:23 +00:00
std::vector<PlsRemap> pls_inputs;
std::vector<PlsRemap> 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
std::string pls_decl(const PlsRemap &variable);
const char *to_pls_qualifiers_glsl(const SPIRVariable &variable);
void emit_pls();
void remap_pls_variables();
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
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
// A variant which takes two sets of name. The secondary is only used to verify there are no collisions,
// but the set is not updated when we have found a new name.
// Used primarily when adding block interface names.
void add_variable(std::unordered_set<std::string> &variables_primary,
Run format_all.sh.
2019-01-07 09:01:28 +00:00
const std::unordered_set<std::string> &variables_secondary, std::string &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
Add support for generic remapping of variables.
2016-07-06 09:04:06 +00:00
void check_function_call_constraints(const uint32_t *args, uint32_t length);
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 handle_invalid_expression(uint32_t id);
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
void find_static_extensions();
Begin implementing for loop initializer propagation.
2016-12-15 16:14:47 +00:00
std::string emit_for_loop_initializers(const SPIRBlock &block);
Deal with loop variable initializers for non-for loops.
2018-08-06 10:52:22 +00:00
void emit_while_loop_initializers(const SPIRBlock &block);
Do not use inline for-loop initializers with different types.
2018-01-16 09:27:58 +00:00
bool for_loop_initializers_are_same_type(const SPIRBlock &block);
Do not use RMW rewrite for matrices. Does not work on MSL.
2018-05-04 08:35:32 +00:00
bool optimize_read_modify_write(const SPIRType &type, const std::string &lhs, const std::string &rhs);
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 fixup_image_load_store_access();
Workaround empty struct declaration and empty IO variables.
2017-03-24 09:03:11 +00:00
bool type_is_empty(const SPIRType &type);
Add vector-less IR construction to subclasses as well.
2017-04-01 14:08:19 +00:00
CompilerMSL support and tests for OpUndef.
2017-11-16 03:44:42 +00:00
virtual void declare_undefined_values();
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
Use packoffset in HLSL. Rewrite how cbuffers are emitted.
2017-10-10 11:15:49 +00:00
static std::string sanitize_underscores(const std::string &str);
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 can_use_io_location(spv::StorageClass storage, bool block);
Overhaul barrier handling in GLSL.
2018-01-09 11:07:07 +00:00
const Instruction *get_next_instruction_in_block(const Instruction &instr);
Rewrite barrier handling in HLSL.
2018-01-09 11:41:13 +00:00
static uint32_t mask_relevant_memory_semantics(uint32_t semantics);
Also check IO location for blocks.
2017-10-19 12:17:18 +00:00
Begin adding float16_t support to GLSL.
2018-03-06 14:32:26 +00:00
std::string convert_half_to_string(const SPIRConstant &value, uint32_t col, uint32_t row);
Support special float constants (NaN/Inf).
2018-02-23 12:06:20 +00:00
std::string convert_float_to_string(const SPIRConstant &value, uint32_t col, uint32_t row);
std::string convert_double_to_string(const SPIRConstant &value, uint32_t col, uint32_t row);
Use GL_EXT_samplerless_texture_functions in Vulkan GLSL.
2018-09-27 11:36:38 +00:00
std::string convert_separate_image_to_expression(uint32_t id);
Build combined dummy samplers for Query functions without sampler as well. Deal with various query functions which require dummy sampler. In SPIR-V, separate images are used, but GLSL (even Vulkan GLSL) requires combined sampler images ...
2018-04-30 09:18:18 +00:00
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +00:00
// Builtins in GLSL are always specific signedness, but the SPIR-V can declare them
// as either unsigned or signed.
// Sometimes we will need to automatically perform bitcasts on load and store to make this work.
virtual void bitcast_to_builtin_store(uint32_t target_id, std::string &expr, const SPIRType &expr_type);
virtual void bitcast_from_builtin_load(uint32_t source_id, std::string &expr, const SPIRType &expr_type);
GLSL: Deal with array loads from input in tessellation. We have an edge case where the array is declared with a concrete size, but in GLSL we must emit an unsized array, which breaks array copies. Deal explicitly with this.
2019-03-21 10:50:53 +00:00
void unroll_array_from_complex_load(uint32_t target_id, uint32_t source_id, std::string &expr);
GLSL: Support GL_EXT_nonuniform_qualifier.
2019-05-02 08:54:34 +00:00
void convert_non_uniform_expression(const SPIRType &type, std::string &expr);
Deal with some builtins being declared with wrong signedness.
2018-06-22 09:30:13 +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
void handle_store_to_invariant_variable(uint32_t store_id, uint32_t value_id);
void disallow_forwarding_in_expression_chain(const SPIRExpression &expr);
MSL: Workaround missing gradient2d() for sampler_compare.
2019-01-07 09:01:00 +00:00
bool expression_is_constant_null(uint32_t id) const;
Avoid unintentional name conflict with HLSL backend.
2019-01-17 11:21:16 +00:00
virtual void emit_store_statement(uint32_t lhs_expression, uint32_t rhs_expression);
MSL: Workaround missing gradient2d() for sampler_compare.
2019-01-07 09:01:00 +00:00
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
uint32_t get_integer_width_for_instruction(const Instruction &instr) const;
Properly deal with sign-dependent GLSL opcodes. The GLSLstd450 spec is very lax about input signs, so we need to do the bitcasting dance to implement it correctly.
2019-03-27 10:53:47 +00:00
uint32_t get_integer_width_for_glsl_instruction(GLSLstd450 op, const uint32_t *arguments, uint32_t length) const;
GLSL/MSL: Implement 8-bit part of VK_KHR_shader_float16_int8. Storage was in place already, so mostly just dealing with bitcasts and constants. Simplies some of the bitcasting logic, and this exposed some bugs in the implementation. Refactor to use correct width integers with explicit bitcast opcodes.
2019-01-30 13:49:55 +00:00
Support LUTs in single-function CFGs on Private storage class. Fairly common pattern in unoptimized SPIR-V. Support this case as well.
2019-02-06 09:38:18 +00:00
bool variable_is_lut(const SPIRVariable &var) const;
Replace locale handling. We were using std::locale::global() to force a C locale which is not safe when SPIRV-Cross is used in a multi-threaded environment. To fix this, we could tap into various per-platform specific locale handling to get safe thread-local locales, but since locales only affect the decimal point in floats, we simply query the locale instead and do the necessary radix replacement ourselves, without touching the locale. This should be much safer and cleaner than the alternative.
2019-02-28 10:26:26 +00:00
char current_locale_radix_character = '.';
MSL: Fix struct declaration order with complex type aliases. MSL generally emits the aliases, which means we cannot always place the master type first, unlike GLSL and HLSL. The logic fix is just to reorder after we have tagged types with packing information, rather than doing it in the parser fixup.
2019-05-23 12:54:04 +00:00
void fixup_type_alias();
void reorder_type_alias();
Propagate NonUniformEXT to dependent expressions. This decoration might only be present for the very last ID which is consumed by a sampling or Load/Store instruction. To make sure our access chains are emitted correctly, we have to back-propagate this decoration.
2019-07-08 09:19:38 +00:00
void propagate_nonuniform_qualifier(uint32_t id);
Add vector-less IR construction to subclasses as well.
2017-04-01 14:08:19 +00:00
private:
Replace locale handling. We were using std::locale::global() to force a C locale which is not safe when SPIRV-Cross is used in a multi-threaded environment. To fix this, we could tap into various per-platform specific locale handling to get safe thread-local locales, but since locales only affect the decimal point in floats, we simply query the locale instead and do the necessary radix replacement ourselves, without touching the locale. This should be much safer and cleaner than the alternative.
2019-02-28 10:26:26 +00:00
void init();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
};
Reduce pressure on global allocation. - Replace ostringstream with custom implementation. ~30% performance uplift on vector-shuffle-oom test. Allocations are measurably reduced in Valgrind. - Replace std::vector with SmallVector. Classic malloc optimization, small vectors are backed by inline data. ~ 7-8% gain on vector-shuffle-oom on GCC 8 on Linux. - Use an object pool for IVariant type. We generally allocate a lot of SPIR* objects. We can amortize these allocations neatly by pooling them. - ~15% overall uplift on ./test_shaders.py --iterations 10000 shaders/.
2019-04-02 09:19:03 +00:00
} // namespace SPIRV_CROSS_NAMESPACE
Initial commit.
2016-03-02 17:09:16 +00:00
#endif
Reference in New Issue Copy Permalink