Added support for newer versions of SPIR-V.

The version config value is now respected for "spirv" shader type and and
used to control the version that is targeted when compiling. Other targets
use the latest version before cross-compiling.

Added support for new storage buffer representation when extracting
uniforms from SPIR-V, which has been in use since SPIR-V 1.6.

SPIR-V version define now follows the standard version code representation.
This also fixes the fact that the define improperly reported the latest
rather than the actual target, and the documentation didn't match how the
version was represented.

The version for Metal is now properly forwarded to SPIRV-Cross for
cross-compilation. This may fix some features not being enabled.

Updated glslang and SPIRV-Cross. Incremented the version to 1.8.0.

Author: akb825

CMakeLists.txt

@@ -89,8 +89,8 @@ if (MSL_OUTPUT_DIR)
 endif()
 
 set(MSL_MAJOR_VERSION 1)
-set(MSL_MINOR_VERSION 7)
-set(MSL_PATCH_VERSION 6)
+set(MSL_MINOR_VERSION 8)
+set(MSL_PATCH_VERSION 0)
 set(MSL_VERSION ${MSL_MAJOR_VERSION}.${MSL_MINOR_VERSION}.${MSL_PATCH_VERSION})
 
 set(MSL_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})

Compile/SPIRV-Cross

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2022 Aaron Barany
+ * Copyright 2016-2025 Aaron Barany
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -436,6 +436,12 @@ class MSL_COMPILE_EXPORT Target
 	 */
 	virtual bool needsReflectionNames() const;
 
+	/**
+	 * @brief Gets the SPIR-V version to compile with.
+	 * @return The SPIR-V version. Defaults to the latest supported version.
+	 */
+	virtual std::uint32_t getSpirVVersion() const;
+
 	/**
 	 * @brief Function called when about to compile a shader.
 	 */

Compile/glslang

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2022 Aaron Barany
+ * Copyright 2016-2025 Aaron Barany
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -39,20 +39,30 @@ namespace msl
 class MSL_COMPILE_EXPORT TargetSpirV : public Target
 {
 public:
+	/**
+	 * @brief Constructs this with the version number.
+	 * @param version The Metal version number.
+	 */
+	explicit TargetSpirV(std::uint32_t version);
+
 	std::uint32_t getId() const override;
 	std::uint32_t getVersion() const override;
 	bool featureSupported(Feature feature) const override;
 	std::vector<std::pair<std::string, std::string>> getExtraDefines() const override;
 
 protected:
 	bool needsReflectionNames() const override;
+	std::uint32_t getSpirVVersion() const override;
 	bool crossCompile(std::vector<std::uint8_t>& data, Output& output,
 		const std::string& fileName, std::size_t line, std::size_t column,
 		const std::array<bool, compile::stageCount>& pipelineStages, compile::Stage stage,
 		const std::vector<std::uint32_t>& spirv, const std::string& entryPoint,
 		const std::vector<compile::Uniform>& uniforms, std::vector<std::uint32_t>& uniformIds,
 		const std::vector<compile::FragmentInputGroup>& fragmentInputs,
 		std::uint32_t fragmentGroup) override;
+
+private:
+	std::uint32_t m_version;
 };
 
 } // namespace msl

Compile/include/MSL/Compile/Target.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2021 Aaron Barany
+ * Copyright 2016-2025 Aaron Barany
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -281,11 +281,13 @@ const TBuiltInResource& Compiler::getDefaultResources()
 
 bool Compiler::compile(Stages& stages, Output &output, const std::string& baseFileName,
 	const std::string& glsl, const std::vector<Parser::LineMapping>& lineMappings,
-	Stage stage, const TBuiltInResource& resources)
+	Stage stage, const TBuiltInResource& resources, std::uint32_t spirvVersion)
 {
 	const char* glslStr = glsl.c_str();
 	std::unique_ptr<glslang::TShader> shader(
 		new glslang::TShader(stageMap[static_cast<unsigned int>(stage)]));
+	shader->setEnvTarget(glslang::EShTargetSpv,
+		static_cast<glslang::EShTargetLanguageVersion>(spirvVersion));
 	shader->setStrings(&glslStr, 1);
 	shader->setAutoMapBindings(true);
 	shader->setAutoMapLocations(true);
@@ -325,6 +327,8 @@ Compiler::SpirV Compiler::assemble(Output& output, const Program& program,
 
 	SpirV spirv;
 	spv::SpvBuildLogger logger;
+	glslang::SpvOptions options;
+	options.generateDebugInfo = true;
 	glslang::GlslangToSpv(*intermediate, spirv, &logger);
 	if (addToOutput(output, logger, pipeline.token->fileName, pipeline.token->line,
 		pipeline.token->column))

Compile/include/MSL/Compile/TargetSpirV.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 Aaron Barany
+ * Copyright 2016-2025 Aaron Barany
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -78,7 +78,7 @@ class MSL_COMPILE_EXPORT Compiler
 
 	static bool compile(Stages& stages, Output& output, const std::string& baseFileName,
 		const std::string& glsl, const std::vector<Parser::LineMapping>& lineMappings,
-		Stage stage, const TBuiltInResource& resources);
+		Stage stage, const TBuiltInResource& resources, std::uint32_t spirvVersion);
 
 	static bool link(Program& program, Output& output, const Parser::Pipeline& pipeline,
 		const Stages& stages);

Compile/src/Compiler.cpp

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 Aaron Barany
+ * Copyright 2016-2025 Aaron Barany
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -29,8 +29,8 @@ std::string MetalOutput::disassemble(Output& output, const Compiler::SpirV& spir
 	spirv_cross::CompilerMSL::Options options;
 	options.platform = ios ? spirv_cross::CompilerMSL::Options::iOS :
 		spirv_cross::CompilerMSL::Options::macOS;
-	options.msl_version = spirv_cross::CompilerMSL::Options::make_msl_version(version/10,
-		version%10);
+	options.msl_version = spirv_cross::CompilerMSL::Options::make_msl_version(version/100,
+		version%100);
 	options.capture_output_to_buffer = outputToBuffer;
 
 	spirv_cross::CompilerMSL compiler(spirv);

Compile/src/Compiler.h

@@ -21,7 +21,6 @@
 #include <MSL/Compile/Types.h>
 #include "TokenList.h"
 #include <array>
-#include <float.h>
 
 namespace msl
 {

Compile/src/MetalOutput.cpp

@@ -22,6 +22,7 @@
 #include <cassert>
 #include <cstring>
 #include <map>
+#include <sstream>
 #include <unordered_map>
 #include <unordered_set>
 
@@ -141,6 +142,7 @@ struct IntermediateData
 	std::map<std::uint32_t, std::uint32_t> inputVars;
 	std::map<std::uint32_t, std::uint32_t> outputVars;
 	std::map<std::uint32_t, std::uint32_t> imageVars;
+	std::map<std::uint32_t, std::uint32_t> storageBufferVars;
 	std::pair<std::uint32_t, std::uint32_t> pushConstantPointer = std::make_pair(unknown, unknown);
 	std::pair<std::uint32_t, std::uint32_t> clipDistanceMember = std::make_pair(unknown, unknown);
 	std::pair<std::uint32_t, std::uint32_t> cullDistanceMember = std::make_pair(unknown, unknown);
@@ -1130,7 +1132,8 @@ std::vector<std::uint32_t> makeArrayLengths(const std::vector<ArrayInfo>& arrayE
 void addUniforms(SpirVProcessor& processor, const IntermediateData& data)
 {
 	bool hasPushConstant = data.pushConstantPointer.first != unknown;
-	std::size_t totalUniforms = data.uniformVars.size() + data.imageVars.size() + hasPushConstant;
+	std::size_t totalUniforms = data.uniformVars.size() + data.imageVars.size() +
+		data.storageBufferVars.size() + hasPushConstant;
 	processor.uniforms.resize(totalUniforms);
 	processor.uniformIds.resize(totalUniforms);
 	std::size_t i = 0;
@@ -1239,6 +1242,43 @@ void addUniforms(SpirVProcessor& processor, const IntermediateData& data)
 
 		++i;
 	}
+
+	for (const auto& storageBufferIndices : data.storageBufferVars)
+	{
+		processor.uniformIds[i] = storageBufferIndices.first;
+		std::uint32_t typeId = storageBufferIndices.second;
+
+		Uniform& uniform = processor.uniforms[i];
+		uniform.type = getType(uniform.arrayElements, uniform.structIndex, processor, data, typeId);
+		if (uniform.type == Type::Struct)
+			uniform.name = processor.structs[uniform.structIndex].name;
+		else
+		{
+			auto foundName = data.names.find(storageBufferIndices.first);
+			assert(foundName != data.names.end());
+			uniform.name = foundName->second;
+		}
+
+
+		uniform.uniformType = UniformType::BlockBuffer;
+
+		auto foundDescriptorSet = data.descriptorSets.find(storageBufferIndices.first);
+		if (foundDescriptorSet == data.descriptorSets.end())
+			uniform.descriptorSet = unknown;
+		else
+			uniform.descriptorSet = foundDescriptorSet->second;
+
+		auto foundBinding = data.bindings.find(storageBufferIndices.first);
+		if (foundBinding == data.bindings.end())
+			uniform.binding = unknown;
+		else
+			uniform.binding = foundBinding->second;
+
+		uniform.inputAttachmentIndex = unknown;
+		uniform.samplerIndex = unknown;
+
+		++i;
+	}
 }
 
 bool addInputsOutputs(Output& output, std::vector<SpirVProcessor::InputOutput>& inputOutputs,
@@ -1985,10 +2025,16 @@ bool SpirVProcessor::extract(Output& output, const std::string& fileName, std::s
 	this->column = column;
 	this->spirv = &spirv;
 
-	MSL_UNUSED(minVersion);
 	assert(spirv.size() > firstInstruction);
 	assert(spirv[0] == spv::MagicNumber);
-	assert(spirv[1] >= minVersion && spirv[1] <= spv::Version);
+	if (spirv[1] < minVersion || spirv[1] > spv::Version)
+	{
+		std::stringstream versionStr;
+		versionStr << std::hex << spirv[1];
+		output.addMessage(Output::Level::Error, fileName, line,
+			column, false, "linker error: invalid SPIR-V version 0x" + versionStr.str());
+		return false;
+	}
 	std::vector<char> tempBuffer;
 
 	IntermediateData data;
@@ -2257,6 +2303,7 @@ bool SpirVProcessor::extract(Output& output, const std::string& fileName, std::s
 					case spv::StorageClassImage:
 					case spv::StorageClassUniformConstant:
 					case spv::StorageClassPushConstant:
+					case spv::StorageClassStorageBuffer:
 						if (data.types.find(type) != data.types.end() ||
 							data.arrayTypes.find(type) != data.arrayTypes.end() ||
 							data.structTypes.find(type) != data.structTypes.end())
@@ -2326,6 +2373,13 @@ bool SpirVProcessor::extract(Output& output, const std::string& fileName, std::s
 						data.pushConstantPointer = std::make_pair(id, foundPointer->second);
 						break;
 					}
+					case spv::StorageClassStorageBuffer:
+					{
+						auto foundPointer = data.pointers.find(pointerType);
+						assert(foundPointer != data.pointers.end());
+						data.storageBufferVars[id] = foundPointer->second;
+						break;
+					}
 					default:
 						break;
 				}