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

447 lines
18 KiB
C++
Raw Normal View History

Initial commit.
2016-03-02 17:09:16 +00:00
/*
Update license headers for 2017.
2017-01-28 08:00:40 +00:00
* Copyright 2015-2017 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
Rename project to SPIRV-Cross. Rename to coincide with moving the project to KhronosGroup.
2016-04-04 07:36:04 +00:00
#include "spirv_cross.hpp"
Initial commit.
2016-03-02 17:09:16 +00:00
#include <sstream>
#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>
Rename project to SPIRV-Cross. Rename to coincide with moving the project to KhronosGroup.
2016-04-04 07:36:04 +00:00
namespace spirv_cross
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;
};
class CompilerGLSL : public Compiler
{
public:
struct Options
{
uint32_t version = 450;
bool es = false;
bool force_temporary = false;
Cleanup, and make cfg analysis optional.
2016-11-18 16:06:49 +00:00
// If true, variables will be moved to their appropriate scope through CFG analysis.
bool cfg_analysis = true;
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 Clang format. Reformats the entire codebase. Better to do it now 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
{
// In vertex shaders, rewrite [0, w] depth (Vulkan/D3D style) to [-w, w] depth (GL style).
bool fixup_clipspace = true;
} 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;
};
void remap_pixel_local_storage(std::vector<PlsRemap> inputs, std::vector<PlsRemap> outputs)
{
pls_inputs = std::move(inputs);
pls_outputs = std::move(outputs);
remap_pls_variables();
}
CompilerGLSL(std::vector<uint32_t> spirv_)
: Compiler(move(spirv_))
{
if (source.known)
{
options.es = source.es;
options.version = source.version;
}
}
const Options &get_options() const
{
return options;
}
void set_options(Options &opts)
{
options = opts;
}
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
Add Clang format. Reformats the entire codebase. Better to do it now 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();
void emit_function(SPIRFunction &func, uint64_t return_flags);
// Virtualize methods which need to be overridden by subclass targets like C++ and such.
virtual void emit_function_prototype(SPIRFunction &func, uint64_t return_flags);
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);
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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();
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);
virtual std::string type_to_glsl(const SPIRType &type);
virtual std::string builtin_to_glsl(spv::BuiltIn builtin);
Flatten varying structs outputs in legacy targets.
2017-02-22 19:17:58 +00:00
virtual std::string member_decl(const SPIRType &type, const SPIRType &member_type, uint32_t member,
const std::string &qualifier = "");
Add Clang format. Reformats the entire codebase. Better to do it now 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 image_type_glsl(const SPIRType &type);
virtual 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();
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
virtual std::string variable_decl(const SPIRType &type, const std::string &name);
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,
bool has_lod, bool has_dref);
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,
bool *p_forward);
Run style formatter.
2017-01-08 13:52:57 +00:00
virtual std::string clean_func_name(std::string func_name);
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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::unique_ptr<std::ostringstream> buffer;
template <typename T>
inline void statement_inner(T &&t)
{
(*buffer) << std::forward<T>(t);
statement_count++;
}
template <typename T, typename... Ts>
inline void statement_inner(T &&t, Ts &&... ts)
{
(*buffer) << std::forward<T>(t);
statement_count++;
statement_inner(std::forward<Ts>(ts)...);
}
template <typename... Ts>
inline void statement(Ts &&... ts)
{
if (redirect_statement)
redirect_statement->push_back(join(std::forward<Ts>(ts)...));
else
{
for (uint32_t i = 0; i < indent; i++)
(*buffer) << " ";
statement_inner(std::forward<Ts>(ts)...);
(*buffer) << '\n';
}
}
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.
std::vector<std::string> *redirect_statement = nullptr;
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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);
Support row-major matrices in access chain when not natively supported by backend (MSL).
2016-12-11 16:01:08 +00:00
Fixes to non-native row-major matrix support. Add support for OpLoad. Throw exception for non-square non-native row-major matrix. Update variable and function names to clarify purposes.
2016-12-14 07:12:52 +00:00
bool is_non_native_row_major_matrix(uint32_t id);
bool member_is_non_native_row_major_matrix(const SPIRType &type, uint32_t index);
virtual std::string convert_row_major_matrix(std::string exp_str);
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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";
Add Clang format. Reformats the entire codebase. Better to do it now 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";
bool swizzle_is_function = false;
bool shared_is_implied = false;
Do not use flexible member arrays in C++. This is supported as compiler extensions, but we can be standards compliant here, so use the classic workaround of having a single entry array at the end of the structs instead.
2016-05-23 07:15:49 +00:00
bool flexible_member_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;
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;
Add Clang format. Reformats the entire codebase. Better to do it now 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);
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 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);
void emit_block_chain(SPIRBlock &block);
Emit spec constants directly with Vulkan semantics. Emit an actual spec constant declaration in Vulkan instead of resolving the constant.
2016-10-03 10:52:56 +00:00
void emit_specialization_constant(const SPIRConstant &constant);
Add Clang format. Reformats the entire codebase. Better to do it now 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 emit_continue_block(uint32_t continue_block);
bool attempt_emit_loop_header(SPIRBlock &block, SPIRBlock::Method method);
void propagate_loop_dominators(const SPIRBlock &block);
void branch(uint32_t from, uint32_t to);
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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);
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);
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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);
void emit_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);
Add Clang format. Reformats the entire codebase. Better to do it now 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);
Fix cases for flattened struct write. Handle writing the entire struct as well as writing the elements individually.
2017-02-23 18:03:07 +00:00
std::string access_chain_internal(uint32_t base, const uint32_t *indices, uint32_t count, bool index_is_literal,
bool chain_only = false, bool *need_transpose = nullptr);
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,
bool *need_transpose = nullptr);
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);
Run style formatter.
2017-01-20 16:33:59 +00:00
std::pair<std::string, uint32_t> flattened_access_chain_offset(uint32_t base, const uint32_t *indices,
uint32_t count, uint32_t offset,
Formatting.
2017-01-21 11:47:26 +00:00
bool *need_transpose = nullptr,
uint32_t *matrix_stride = 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 char *index_to_swizzle(uint32_t index);
std::string remap_swizzle(uint32_t result_type, uint32_t input_components, uint32_t expr);
std::string declare_temporary(uint32_t type, uint32_t id);
Run clang-format.
2016-10-24 13:24:24 +00:00
void append_global_func_args(const SPIRFunction &func, uint32_t index, std::vector<std::string> &arglist);
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
std::string to_expression(uint32_t id);
Defer parenthesis generation until needed. Previously, we would generate parentheses proactively when generating binary ops, however, this leads to uglier code and hits warnings in compilers when used as a conditional.
2016-12-05 09:22:54 +00:00
std::string to_enclosed_expression(uint32_t id);
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);
std::string type_to_glsl_constructor(const SPIRType &type);
std::string argument_decl(const SPIRFunction::Parameter &arg);
std::string to_qualifiers_glsl(uint32_t id);
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);
Add Clang format. Reformats the entire codebase. Better to do it now 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 *flags_to_precision_qualifiers_glsl(const SPIRType &type, uint64_t flags);
const char *format_to_glsl(spv::ImageFormat format);
std::string layout_for_member(const SPIRType &type, uint32_t index);
Handle interpolation qualifiers inside IO blocks.
2016-10-07 14:27:39 +00:00
std::string to_interpolation_qualifiers(uint64_t 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
uint64_t combined_decoration_for_member(const SPIRType &type, uint32_t index);
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);
Skip arguments if necessary.
2016-09-11 11:05:44 +00:00
bool skip_argument(uint32_t id) 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
bool ssbo_is_std430_packing(const SPIRType &type);
Add support for FP64 in GLSL.
2016-07-27 08:59:00 +00:00
uint32_t type_to_std430_base_size(const 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
uint32_t type_to_std430_alignment(const SPIRType &type, uint64_t flags);
uint32_t type_to_std430_array_stride(const SPIRType &type, uint64_t flags);
uint32_t type_to_std430_size(const SPIRType &type, uint64_t flags);
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);
std::string bitcast_glsl_op(const SPIRType &result_type, const SPIRType &argument_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
std::string build_composite_combiner(const uint32_t *elems, uint32_t length);
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);
Change variable names beginning with gl_ in GLSL Using old-school GLSL as input containing code ala "gl_FragColor = whatever" resulted in illegal declarations ala "out vec4 gl_FragColor;".
2016-08-12 22:14:52 +00:00
void replace_illegal_names();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
void replace_fragment_output(SPIRVariable &var);
void replace_fragment_outputs();
std::string legacy_tex_op(const std::string &op, const SPIRType &imgtype);
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);
std::string to_flattened_struct_member(const SPIRType &type, 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;
std::unordered_set<uint32_t> forced_temporaries;
std::unordered_set<uint32_t> forwarded_temporaries;
void track_expression_read(uint32_t id);
std::unordered_set<std::string> forced_extensions;
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
std::vector<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
uint32_t statement_count;
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();
// GL_EXT_shader_pixel_local_storage support.
std::vector<PlsRemap> pls_inputs;
std::vector<PlsRemap> pls_outputs;
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
void add_variable(std::unordered_set<std::string> &variables, uint32_t id);
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);
Optimize for read-modify-writes. Required for legacy loop increments.
2016-12-16 12:14:22 +00:00
bool optimize_read_modify_write(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();
Add Clang format. Reformats the entire codebase. Better to do it now than later. Adds .clang-format and a convenience script format_all.sh which formats everything automatically.
2016-05-05 07:33:18 +00:00
};
Initial commit.
2016-03-02 17:09:16 +00:00
}
#endif
Reference in New Issue Copy Permalink