Version 3.2.0 [release 3.2.0]

Author: halx99

3rdparty/spirv-cross/spirv_cross.cpp

@@ -742,6 +742,14 @@ bool Compiler::is_physical_pointer(const SPIRType &type) const
 	return type.op == OpTypePointer && type.storage == StorageClassPhysicalStorageBuffer;
 }
 
+bool Compiler::is_physical_or_buffer_pointer(const SPIRType &type) const
+{
+	return type.op == OpTypePointer &&
+	       (type.storage == StorageClassPhysicalStorageBuffer || type.storage == StorageClassUniform ||
+	        type.storage == StorageClassStorageBuffer || type.storage == StorageClassWorkgroup ||
+	        type.storage == StorageClassPushConstant);
+}
+
 bool Compiler::is_physical_pointer_to_buffer_block(const SPIRType &type) const
 {
 	return is_physical_pointer(type) && get_pointee_type(type).self == type.parent_type &&

3rdparty/spirv-cross/spirv_cross.hpp

@@ -694,6 +694,7 @@ class Compiler
 	bool is_array(const SPIRType &type) const;
 	bool is_pointer(const SPIRType &type) const;
 	bool is_physical_pointer(const SPIRType &type) const;
+	bool is_physical_or_buffer_pointer(const SPIRType &type) const;
 	bool is_physical_pointer_to_buffer_block(const SPIRType &type) const;
 	static bool is_runtime_size_array(const SPIRType &type);
 	uint32_t expression_type_id(uint32_t id) const;

3rdparty/spirv-cross/spirv_glsl.cpp

@@ -5054,10 +5054,10 @@ void CompilerGLSL::emit_polyfills(uint32_t polyfills, bool relaxed)
 // Returns a string representation of the ID, usable as a function arg.
 // Default is to simply return the expression representation fo the arg ID.
 // Subclasses may override to modify the return value.
-string CompilerGLSL::to_func_call_arg(const SPIRFunction::Parameter &, uint32_t id)
+string CompilerGLSL::to_func_call_arg(const SPIRFunction::Parameter &arg, uint32_t id)
 {
 	// BDA expects pointers through function interface.
-	if (is_physical_pointer(expression_type(id)))
+	if (!arg.alias_global_variable && is_physical_or_buffer_pointer(expression_type(id)))
 		return to_pointer_expression(id);
 
 	// Make sure that we use the name of the original variable, and not the parameter alias.
@@ -6899,6 +6899,16 @@ void CompilerGLSL::emit_uninitialized_temporary(uint32_t result_type, uint32_t r
 	}
 }
 
+bool CompilerGLSL::can_declare_inline_temporary(uint32_t id) const
+{
+	if (!block_temporary_hoisting && current_continue_block && !hoisted_temporaries.count(id))
+		return false;
+	if (hoisted_temporaries.count(id))
+		return false;
+
+	return true;
+}
+
 string CompilerGLSL::declare_temporary(uint32_t result_type, uint32_t result_id)
 {
 	auto &type = get<SPIRType>(result_type);
@@ -6976,6 +6986,42 @@ SPIRExpression &CompilerGLSL::emit_op(uint32_t result_type, uint32_t result_id,
 	}
 }
 
+void CompilerGLSL::emit_transposed_op(uint32_t result_type, uint32_t result_id, const string &rhs, bool forwarding)
+{
+	if (forwarding && (forced_temporaries.find(result_id) == end(forced_temporaries)))
+	{
+		// Just forward it without temporary.
+		// If the forward is trivial, we do not force flushing to temporary for this expression.
+		forwarded_temporaries.insert(result_id);
+		auto &e = set<SPIRExpression>(result_id, rhs, result_type, true);
+		e.need_transpose = true;
+	}
+	else if (can_declare_inline_temporary(result_id))
+	{
+		// If expression isn't immutable, bind it to a temporary and make the new temporary immutable (they always are).
+		// Since the expression is transposed, we have to ensure the temporary is the transposed type.
+
+		auto &transposed_type_id = extra_sub_expressions[result_id];
+		if (!transposed_type_id)
+		{
+			auto dummy_type = get<SPIRType>(result_type);
+			std::swap(dummy_type.columns, dummy_type.vecsize);
+			transposed_type_id = ir.increase_bound_by(1);
+			set<SPIRType>(transposed_type_id, dummy_type);
+		}
+
+		statement(declare_temporary(transposed_type_id, result_id), rhs, ";");
+		auto &e = set<SPIRExpression>(result_id, to_name(result_id), result_type, true);
+		e.need_transpose = true;
+	}
+	else
+	{
+		// If we cannot declare the temporary because it's already been hoisted, we don't have the
+		// chance to override the temporary type ourselves. Just transpose() the expression.
+		emit_op(result_type, result_id, join("transpose(", rhs, ")"), forwarding);
+	}
+}
+
 void CompilerGLSL::emit_unary_op(uint32_t result_type, uint32_t result_id, uint32_t op0, const char *op)
 {
 	bool forward = should_forward(op0);
@@ -11586,7 +11632,7 @@ bool CompilerGLSL::should_dereference(uint32_t id)
 	// If id is a variable but not a phi variable, we should not dereference it.
 	// BDA passed around as parameters are always pointers.
 	if (auto *var = maybe_get<SPIRVariable>(id))
-		return (var->parameter && is_physical_pointer(type)) || var->phi_variable;
+		return (var->parameter && is_physical_or_buffer_pointer(type)) || var->phi_variable;
 
 	if (auto *expr = maybe_get<SPIRExpression>(id))
 	{
@@ -11622,8 +11668,8 @@ bool CompilerGLSL::should_dereference(uint32_t id)
 bool CompilerGLSL::should_dereference_caller_param(uint32_t id)
 {
 	const auto &type = expression_type(id);
-	// BDA is always passed around as pointers.
-	if (is_physical_pointer(type))
+	// BDA is always passed around as pointers. Similarly, we need to pass variable buffer pointers as pointers.
+	if (is_physical_or_buffer_pointer(type))
 		return false;
 
 	return should_dereference(id);
@@ -13512,8 +13558,7 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction)
 			auto expr = join(enclose_expression(to_unpacked_row_major_matrix_expression(ops[3])), " * ",
 			                 enclose_expression(to_unpacked_row_major_matrix_expression(ops[2])));
 			bool forward = should_forward(ops[2]) && should_forward(ops[3]);
-			auto &e = emit_op(ops[0], ops[1], expr, forward);
-			e.need_transpose = true;
+			emit_transposed_op(ops[0], ops[1], expr, forward);
 			a->need_transpose = true;
 			b->need_transpose = true;
 			inherit_expression_dependencies(ops[1], ops[2]);
@@ -13536,8 +13581,7 @@ void CompilerGLSL::emit_instruction(const Instruction &instruction)
 			auto expr = join(enclose_expression(to_unpacked_row_major_matrix_expression(ops[2])), " * ",
 			                 to_enclosed_unpacked_expression(ops[3]));
 			bool forward = should_forward(ops[2]) && should_forward(ops[3]);
-			auto &e = emit_op(ops[0], ops[1], expr, forward);
-			e.need_transpose = true;
+			emit_transposed_op(ops[0], ops[1], expr, forward);
 			a->need_transpose = true;
 			inherit_expression_dependencies(ops[1], ops[2]);
 			inherit_expression_dependencies(ops[1], ops[3]);

3rdparty/spirv-cross/spirv_glsl.hpp

@@ -775,6 +775,7 @@ class CompilerGLSL : public Compiler
 	bool expression_read_implies_multiple_reads(uint32_t id) const;
 	SPIRExpression &emit_op(uint32_t result_type, uint32_t result_id, const std::string &rhs, bool forward_rhs,
 	                        bool suppress_usage_tracking = false);
+	void emit_transposed_op(uint32_t result_type, uint32_t result_id, const std::string &rhs, bool forward_rhs);
 
 	void access_chain_internal_append_index(std::string &expr, uint32_t base, const SPIRType *type,
 	                                        AccessChainFlags flags, bool &access_chain_is_arrayed, uint32_t index);
@@ -817,6 +818,7 @@ class CompilerGLSL : public Compiler
 	const char *index_to_swizzle(uint32_t index);
 	std::string remap_swizzle(const SPIRType &result_type, uint32_t input_components, const std::string &expr);
 	std::string declare_temporary(uint32_t type, uint32_t id);
+	bool can_declare_inline_temporary(uint32_t id) const;
 	void emit_uninitialized_temporary(uint32_t type, uint32_t id);
 	SPIRExpression &emit_uninitialized_temporary_expression(uint32_t type, uint32_t id);
 	virtual void append_global_func_args(const SPIRFunction &func, uint32_t index, SmallVector<std::string> &arglist);

3rdparty/spirv-cross/spirv_hlsl.cpp

@@ -491,9 +491,9 @@ string CompilerHLSL::type_to_glsl(const SPIRType &type, uint32_t id)
 		case SPIRType::Double:
 			return join("double", type.vecsize);
 		case SPIRType::Int64:
-			return join("i64vec", type.vecsize);
+			return join("int64_t", type.vecsize);
 		case SPIRType::UInt64:
-			return join("u64vec", type.vecsize);
+			return join("uint64_t", type.vecsize);
 		default:
 			return "???";
 		}
@@ -1434,11 +1434,13 @@ bool CompilerHLSL::is_hlsl_aux_buffer_binding_used(HLSLAuxBinding binding) const
 		return false;
 }
 
+// axslcc spec
 void CompilerHLSL::add_hlsl_sampler_state(uint32_t slot, const std::string &sampler_state_symbol)
 {
 	sampler_registry.emplace(slot, sampler_state_symbol);
 }
 
+// axslcc spec
 uint32_t CompilerHLSL::resolve_sampler_variable(uint32_t id) const
 {
 	if (ir.ids[id].get_type() == TypeVariable)
@@ -1617,6 +1619,7 @@ void CompilerHLSL::replace_illegal_names()
 		"Texture3D", "TextureCube", "TextureCubeArray", "true", "typedef", "triangle",
 		"triangleadj", "TriangleStream", "uint", "uniform", "unorm", "unsigned",
 		"vector", "vertexfragment", "VertexShader", "vertices", "void", "volatile", "while",
+		"signed",
 	};
 
 	CompilerGLSL::replace_illegal_names(keywords);
@@ -1731,9 +1734,11 @@ void CompilerHLSL::emit_resources()
 		ir.for_each_typed_id<SPIRVariable>([&](uint32_t, SPIRVariable &var) {
 			auto &type = this->get<SPIRType>(var.basetype);
 
+			bool is_hidden = is_hidden_io_variable(var);
+
 			if (var.storage != StorageClassFunction && !var.remapped_variable && type.pointer &&
 			   (var.storage == StorageClassInput || var.storage == StorageClassOutput) && !is_builtin_variable(var) &&
-			   interface_variable_exists_in_entry_point(var.self))
+			   interface_variable_exists_in_entry_point(var.self) && !is_hidden)
 			{
 				// Builtin variables are handled separately.
 				emit_interface_block_globally(var);
@@ -1769,8 +1774,10 @@ void CompilerHLSL::emit_resources()
 		if (var.storage != StorageClassInput && var.storage != StorageClassOutput)
 			return;
 
+		bool is_hidden = is_hidden_io_variable(var);
+
 		if (!var.remapped_variable && type.pointer && !is_builtin_variable(var) &&
-		    interface_variable_exists_in_entry_point(var.self))
+		    interface_variable_exists_in_entry_point(var.self) && !is_hidden)
 		{
 			if (block)
 			{
@@ -3504,10 +3511,12 @@ void CompilerHLSL::emit_hlsl_entry_point()
 		if (var.storage != StorageClassInput)
 			return;
 
+		bool is_hidden = is_hidden_io_variable(var);
+
 		bool need_matrix_unroll = var.storage == StorageClassInput && execution.model == ExecutionModelVertex;
 
 		if (!var.remapped_variable && type.pointer && !is_builtin_variable(var) &&
-		    interface_variable_exists_in_entry_point(var.self))
+		    interface_variable_exists_in_entry_point(var.self) && !is_hidden)
 		{
 			if (block)
 			{
@@ -7158,6 +7167,30 @@ bool CompilerHLSL::is_hlsl_force_storage_buffer_as_uav(ID id) const
 	return (force_uav_buffer_bindings.find({ desc_set, binding }) != force_uav_buffer_bindings.end());
 }
 
+bool CompilerHLSL::is_hidden_io_variable(const SPIRVariable &var) const
+{
+	if (!is_hidden_variable(var))
+		return false;
+
+	// It is too risky to remove stage IO variables that are linkable since it affects link compatibility.
+	// For vertex inputs and fragment outputs, it's less of a concern and we want reflection data
+	// to match reality.
+
+	bool is_external_linkage =
+			(get_execution_model() == ExecutionModelVertex && var.storage == StorageClassInput) ||
+			(get_execution_model() == ExecutionModelFragment && var.storage == StorageClassOutput);
+
+	if (!is_external_linkage)
+		return false;
+
+	// Unused output I/O variables might still be required to implement framebuffer fetch.
+	if (var.storage == StorageClassOutput && !is_legacy() &&
+	    location_is_framebuffer_fetch(get_decoration(var.self, DecorationLocation)) != 0)
+		return false;
+
+	return true;
+}
+
 void CompilerHLSL::set_hlsl_force_storage_buffer_as_uav(uint32_t desc_set, uint32_t binding)
 {
 	SetBindingPair pair = { desc_set, binding };

3rdparty/spirv-cross/spirv_hlsl.hpp

@@ -303,6 +303,7 @@ class CompilerHLSL : public CompilerGLSL
 	SPIRType::BaseType get_builtin_basetype(BuiltIn builtin, SPIRType::BaseType default_type) override;
 
 	bool is_hlsl_force_storage_buffer_as_uav(ID id) const;
+	bool is_hidden_io_variable(const SPIRVariable &var) const;
 
 	Options hlsl_options;