diff options
Diffstat (limited to 'source')
25 files changed, 1070 insertions, 481 deletions
diff --git a/source/compiler-core/slang-perfect-hash-codegen.cpp b/source/compiler-core/slang-perfect-hash-codegen.cpp new file mode 100644 index 000000000..611b34c54 --- /dev/null +++ b/source/compiler-core/slang-perfect-hash-codegen.cpp @@ -0,0 +1,81 @@ +#include "slang-perfect-hash-codegen.h" +#include "../core/slang-io.h" + +namespace Slang +{ + SlangResult writeHashFile( + String outCppPath, + String valueType, + const List<String> includes, + const HashParams& hashParams, + const List<String> values) + { + StringBuilder sb; + StringWriter writer(&sb, WriterFlags(0)); + WriterHelper w(&writer); + + w.print("// Hash function for %s\n", valueType.getBuffer()); + w.print("//\n"); + w.print("// This file was thoughtfully generated by a machine,\n"); + w.print("// don't even think about modifying it yourself!\n"); + w.print("//\n"); + w.print("\n"); + for (const auto& i : includes) + { + if (i.getLength()) + w.print("#include \"%s\"\n", i.getBuffer()); + } + w.print("\n"); + w.print("\n"); + w.print("namespace Slang\n"); + w.print("{\n"); + w.print("\n"); + + w.put(perfectHashToEmbeddableCpp( + hashParams, + valueType.getUnownedSlice(), + (String("lookup") + valueType).getUnownedSlice(), + values + ).getBuffer()); + + w.print("}\n"); + + return File::writeAllTextIfChanged(outCppPath, sb.getUnownedSlice()); + } + + SlangResult writePerfectHashLookupCppFile(String fileName, List<String> opnames, String enumName, String enumerantPrefix, String enumHeaderFile, DiagnosticSink* sink) + { + HashParams hashParams; + auto r = minimalPerfectHash(opnames, hashParams); + switch (r) + { + case HashFindResult::UnavoidableHashCollision: + { + sink->diagnoseRaw( + Severity::Error, + "Unable to find a non-overlapping hash function.\n" + "The hash function probably has a unavoidable " + "collision for some input words\n"); + return SLANG_FAIL; + } + case HashFindResult::NonUniqueKeys: + { + sink->diagnoseRaw(Severity::Error, "Input word list has duplicates\n"); + return SLANG_FAIL; + } + case HashFindResult::Success:; + } + + List<String> values; + values.reserve(hashParams.destTable.getCount()); + for (const auto& v : hashParams.destTable) + values.add(enumerantPrefix + v); + return writeHashFile( + fileName, + enumName, + { "../core/slang-common.h", "../core/slang-string.h", enumHeaderFile }, + hashParams, + values); + } + +} diff --git a/source/compiler-core/slang-perfect-hash-codegen.h b/source/compiler-core/slang-perfect-hash-codegen.h new file mode 100644 index 000000000..557f4dba5 --- /dev/null +++ b/source/compiler-core/slang-perfect-hash-codegen.h @@ -0,0 +1,9 @@ +#pragma once + +#include "slang-perfect-hash.h" +#include "slang-diagnostic-sink.h" + +namespace Slang +{ + SlangResult writePerfectHashLookupCppFile(String fileName, List<String> opnames, String enumName, String enumPrefix, String enumHeaderFile, DiagnosticSink* sink); +} diff --git a/source/compiler-core/slang-perfect-hash.cpp b/source/compiler-core/slang-perfect-hash.cpp index bfe8d4876..d5c4902ed 100644 --- a/source/compiler-core/slang-perfect-hash.cpp +++ b/source/compiler-core/slang-perfect-hash.cpp @@ -208,7 +208,7 @@ String perfectHashToEmbeddableCpp( line("}"); line(""); - return sb; + return sb.produceString(); } } diff --git a/source/slang/CMakeLists.txt b/source/slang/CMakeLists.txt index c3ea18433..44785559f 100644 --- a/source/slang/CMakeLists.txt +++ b/source/slang/CMakeLists.txt @@ -47,6 +47,54 @@ target_include_directories( ) # +# generate capability files +# +glob_append(SLANG_CAPABILITY_SOURCE "*.capdef") + +set(SLANG_CAPABILITY_OUTPUT_DIR "${CMAKE_CURRENT_BINARY_DIR}/capability") + +# Generate the output file list +set(SLANG_CAPABILITY_GENERATED_FILES + "${SLANG_CAPABILITY_OUTPUT_DIR}/slang-generated-capability-defs.h" + "${SLANG_CAPABILITY_OUTPUT_DIR}/slang-generated-capability-defs-impl.h" + "${SLANG_CAPABILITY_OUTPUT_DIR}/slang-lookup-capability-defs.cpp" +) +add_custom_command( + OUTPUT ${SLANG_CAPABILITY_GENERATED_FILES} + COMMAND ${CMAKE_COMMAND} -E make_directory ${SLANG_CAPABILITY_OUTPUT_DIR} + COMMAND + slang-capability-generator ${SLANG_CAPABILITY_SOURCE} --target-directory ${SLANG_CAPABILITY_OUTPUT_DIR} + DEPENDS ${SLANG_CAPABILITY_SOURCE} + WORKING_DIRECTORY ${CMAKE_CURRENT_LIST_DIR} + VERBATIM +) +add_library( + slang-capability-defs + INTERFACE + EXCLUDE_FROM_ALL + ${SLANG_CAPABILITY_GENERATED_FILES} +) +set_target_properties(slang-capability-defs PROPERTIES FOLDER generated) +target_include_directories( + slang-capability-defs + INTERFACE ${SLANG_CAPABILITY_OUTPUT_DIR} + INTERFACE ${slang_SOURCE_DIR}/source/slang +) + +add_library( + slang-capability-lookup + INTERFACE + EXCLUDE_FROM_ALL + ${SLANG_CAPABILITY_GENERATED_FILES} +) +set_target_properties(slang-capability-lookup PROPERTIES FOLDER generated) +target_sources( + slang-capability-lookup + INTERFACE + "${SLANG_CAPABILITY_OUTPUT_DIR}/slang-lookup-capability-defs.cpp" +) + +# # generated headers for reflection # @@ -118,6 +166,8 @@ slang_add_target( core compiler-core # Bundle the source unconditionally + slang-capability-defs + slang-capability-lookup slang-meta-headers slang-reflect-headers SPIRV-Headers @@ -164,6 +214,8 @@ slang_add_target( core compiler-core prelude + slang-capability-defs + slang-capability-lookup slang-reflect-headers SPIRV-Headers # slang.h is in the project root, so include that directory in the interface diff --git a/source/slang/hlsl.meta.slang b/source/slang/hlsl.meta.slang index 2f4064c97..3635069e7 100644 --- a/source/slang/hlsl.meta.slang +++ b/source/slang/hlsl.meta.slang @@ -4566,8 +4566,8 @@ T GetAttributeAtVertex(T attribute, uint vertexIndex) { case hlsl: __intrinsic_asm "GetAttributeAtVertex"; - case GL_NV_fragment_shader_barycentric: - case GL_EXT_fragment_shader_barycentric: + case _GL_NV_fragment_shader_barycentric: + case _GL_EXT_fragment_shader_barycentric: __intrinsic_asm "$0[$1]"; case spirv: return spirv_asm { @@ -4599,8 +4599,8 @@ vector<T,N> GetAttributeAtVertex(vector<T,N> attribute, uint vertexIndex) { case hlsl: __intrinsic_asm "GetAttributeAtVertex"; - case GL_NV_fragment_shader_barycentric: - case GL_EXT_fragment_shader_barycentric: + case _GL_NV_fragment_shader_barycentric: + case _GL_EXT_fragment_shader_barycentric: __intrinsic_asm "$0[$1]"; case spirv: return spirv_asm { @@ -4632,8 +4632,8 @@ matrix<T,N,M> GetAttributeAtVertex(matrix<T,N,M> attribute, uint vertexIndex) { case hlsl: __intrinsic_asm "GetAttributeAtVertex"; - case GL_NV_fragment_shader_barycentric: - case GL_EXT_fragment_shader_barycentric: + case _GL_NV_fragment_shader_barycentric: + case _GL_EXT_fragment_shader_barycentric: __intrinsic_asm "$0[$1]"; case spirv: return spirv_asm { @@ -9312,8 +9312,8 @@ bool __reportIntersection(float tHit, uint hitKind) { __target_switch { - case GL_EXT_ray_tracing: __intrinsic_asm "reportIntersectionEXT"; - case GL_NV_ray_tracing: __intrinsic_asm "reportIntersectionNV"; + case _GL_EXT_ray_tracing: __intrinsic_asm "reportIntersectionEXT"; + case _GL_NV_ray_tracing: __intrinsic_asm "reportIntersectionNV"; case spirv: return spirv_asm { result:$$bool = OpReportIntersectionKHR $tHit $hitKind; @@ -9339,8 +9339,8 @@ void IgnoreHit() __target_switch { case hlsl: __intrinsic_asm "IgnoreHit"; - case GL_EXT_ray_tracing: __intrinsic_asm "ignoreIntersectionEXT;"; - case GL_NV_ray_tracing: __intrinsic_asm "ignoreIntersectionNV"; + case _GL_EXT_ray_tracing: __intrinsic_asm "ignoreIntersectionEXT;"; + case _GL_NV_ray_tracing: __intrinsic_asm "ignoreIntersectionNV"; case cuda: __intrinsic_asm "optixIgnoreIntersection"; case spirv: spirv_asm { OpIgnoreIntersectionKHR; %_ = OpLabel }; } @@ -9352,8 +9352,8 @@ void AcceptHitAndEndSearch() __target_switch { case hlsl: __intrinsic_asm "AcceptHitAndEndSearch"; - case GL_EXT_ray_tracing: __intrinsic_asm "terminateRayEXT;"; - case GL_NV_ray_tracing: __intrinsic_asm "terminateRayNV"; + case _GL_EXT_ray_tracing: __intrinsic_asm "terminateRayEXT;"; + case _GL_NV_ray_tracing: __intrinsic_asm "terminateRayNV"; case cuda: __intrinsic_asm "optixTerminateRay"; case spirv: spirv_asm { OpTerminateRayKHR; %_ = OpLabel }; } @@ -9371,8 +9371,8 @@ uint3 DispatchRaysIndex() __target_switch { case hlsl: __intrinsic_asm "DispatchRaysIndex"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_LaunchIDEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_LaunchIDNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_LaunchIDEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_LaunchIDNV)"; case cuda: __intrinsic_asm "optixGetLaunchIndex"; case spirv: return spirv_asm { @@ -9386,8 +9386,8 @@ uint3 DispatchRaysDimensions() __target_switch { case hlsl: __intrinsic_asm "DispatchRaysDimensions"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_LaunchSizeEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_LaunchSizeNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_LaunchSizeEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_LaunchSizeNV)"; case cuda: __intrinsic_asm "optixGetLaunchDimensions"; case spirv: return spirv_asm { @@ -9403,8 +9403,8 @@ float3 WorldRayOrigin() __target_switch { case hlsl: __intrinsic_asm "WorldRayOrigin"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_WorldRayOriginEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_WorldRayOriginNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_WorldRayOriginEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_WorldRayOriginNV)"; case cuda: __intrinsic_asm "optixGetWorldRayOrigin"; case spirv: return spirv_asm { @@ -9418,8 +9418,8 @@ float3 WorldRayDirection() __target_switch { case hlsl: __intrinsic_asm "WorldRayDirection"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_WorldRayDirectionEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_WorldRayDirectionNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_WorldRayDirectionEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_WorldRayDirectionNV)"; case cuda: __intrinsic_asm "optixGetWorldRayDirection"; case spirv: return spirv_asm { @@ -9433,8 +9433,8 @@ float RayTMin() __target_switch { case hlsl: __intrinsic_asm "RayTMin"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_RayTminEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_RayTminNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_RayTminEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_RayTminNV)"; case cuda: __intrinsic_asm "optixGetRayTmin"; case spirv: return spirv_asm { @@ -9458,8 +9458,8 @@ float RayTCurrent() __target_switch { case hlsl: __intrinsic_asm "RayTCurrent"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_RayTmaxEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_RayTmaxNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_RayTmaxEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_RayTmaxNV)"; case cuda: __intrinsic_asm "optixGetRayTmax"; case spirv: return spirv_asm { @@ -9473,8 +9473,8 @@ uint RayFlags() __target_switch { case hlsl: __intrinsic_asm "RayFlags"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_IncomingRayFlagsEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_IncomingRayFlagsNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_IncomingRayFlagsEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_IncomingRayFlagsNV)"; case cuda: __intrinsic_asm "optixGetRayFlags"; case spirv: return spirv_asm { @@ -9490,7 +9490,7 @@ uint InstanceIndex() __target_switch { case hlsl: __intrinsic_asm "InstanceIndex"; - case __glslRayTracing: __intrinsic_asm "(gl_InstanceID)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_InstanceID)"; case cuda: __intrinsic_asm "optixGetInstanceIndex"; case spirv: return spirv_asm { @@ -9504,8 +9504,8 @@ uint InstanceID() __target_switch { case hlsl: __intrinsic_asm "InstanceID"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_InstanceCustomIndexEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_InstanceCustomIndexNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_InstanceCustomIndexEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_InstanceCustomIndexNV)"; case cuda: __intrinsic_asm "optixGetInstanceId"; case spirv: return spirv_asm { @@ -9519,7 +9519,7 @@ uint PrimitiveIndex() __target_switch { case hlsl: __intrinsic_asm "PrimitiveIndex"; - case __glslRayTracing: __intrinsic_asm "(gl_PrimitiveID)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_PrimitiveID)"; case cuda: __intrinsic_asm "optixGetPrimitiveIndex"; case spirv: return spirv_asm { @@ -9533,8 +9533,8 @@ float3 ObjectRayOrigin() __target_switch { case hlsl: __intrinsic_asm "ObjectRayOrigin"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_ObjectRayOriginEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_ObjectRayOriginNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_ObjectRayOriginEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_ObjectRayOriginNV)"; case cuda: __intrinsic_asm "optixGetObjectRayOrigin"; case spirv: return spirv_asm { @@ -9548,8 +9548,8 @@ float3 ObjectRayDirection() __target_switch { case hlsl: __intrinsic_asm "ObjectRayDirection"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_ObjectRayDirectionEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_ObjectRayDirectionNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_ObjectRayDirectionEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_ObjectRayDirectionNV)"; case cuda: __intrinsic_asm "optixGetObjectRayDirection"; case spirv: return spirv_asm { @@ -9565,8 +9565,8 @@ float3x4 ObjectToWorld3x4() __target_switch { case hlsl: __intrinsic_asm "ObjectToWorld3x4"; - case GL_EXT_ray_tracing: __intrinsic_asm "transpose(gl_ObjectToWorldEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "transpose(gl_ObjectToWorldNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "transpose(gl_ObjectToWorldEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "transpose(gl_ObjectToWorldNV)"; case spirv: return spirv_asm { %mat:$$float4x3 = OpLoad builtin(ObjectToWorldKHR:float4x3); @@ -9580,8 +9580,8 @@ float3x4 WorldToObject3x4() __target_switch { case hlsl: __intrinsic_asm "WorldToObject3x4"; - case GL_EXT_ray_tracing: __intrinsic_asm "transpose(gl_WorldToObjectEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "transpose(gl_WorldToObjectNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "transpose(gl_WorldToObjectEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "transpose(gl_WorldToObjectNV)"; case spirv: return spirv_asm { %mat:$$float4x3 = OpLoad builtin(WorldToObjectKHR:float4x3); @@ -9595,8 +9595,8 @@ float4x3 ObjectToWorld4x3() __target_switch { case hlsl: __intrinsic_asm "ObjectToWorld4x3"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_ObjectToWorldEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_ObjectToWorldNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_ObjectToWorldEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_ObjectToWorldNV)"; case spirv: return spirv_asm { result:$$float4x3 = OpLoad builtin(ObjectToWorldKHR:float4x3); @@ -9609,8 +9609,8 @@ float4x3 WorldToObject4x3() __target_switch { case hlsl: __intrinsic_asm "WorldToObject4x3"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_WorldToObjectEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_WorldToObjectNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_WorldToObjectEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_WorldToObjectNV)"; case spirv: return spirv_asm { result:$$float4x3 = OpLoad builtin(WorldToObjectKHR:float4x3); @@ -9656,8 +9656,8 @@ uint HitKind() __target_switch { case hlsl: __intrinsic_asm "HitKind"; - case GL_EXT_ray_tracing: __intrinsic_asm "(gl_HitKindEXT)"; - case GL_NV_ray_tracing: __intrinsic_asm "(gl_HitKindNV)"; + case _GL_EXT_ray_tracing: __intrinsic_asm "(gl_HitKindEXT)"; + case _GL_NV_ray_tracing: __intrinsic_asm "(gl_HitKindNV)"; case cuda: __intrinsic_asm "optixGetHitKind"; case spirv: return spirv_asm { @@ -9848,7 +9848,7 @@ extension __TextureImpl<T,__Shape2D, 1, 0, 0, $(kStdlibResourceAccessFeedback), // // Get the index of the geometry that was hit in an intersection, any-hit, or closest-hit shader -__target_intrinsic(GL_EXT_ray_tracing, "(gl_GeometryIndexEXT)") +__glsl_extension(GL_EXT_ray_tracing) uint GeometryIndex() { __target_switch diff --git a/source/slang/slang-capabilities.capdef b/source/slang/slang-capabilities.capdef new file mode 100644 index 000000000..7e5931edf --- /dev/null +++ b/source/slang/slang-capabilities.capdef @@ -0,0 +1,135 @@ +// This file is the single source of truth for all capabilities +// supported by the Slang language. +// +// This file will be parsed and processed by the slang-capability-generator +// tool during the build process to produce slang-generated-capability-defs.h +// and slang-generated-capability-defs-impl.h files that constitute the final +// C++ source of the compiler. New capabilties should be added by editing +// this file instead of the generated .h files. +// +// A capability atom represent a basic unit that characterizes a single code-gen target or +// a platform-specific API/feature, e.g. _GL_EXT_ray_tracing represents the GLSL ray tracing +// extension, and `glsl` represents the GLSL code gen target. +// +// A capability name is defined by a unique disjunction of conjunction of capability atoms. +// For example, `raytracing` is a name that expands to +// glsl + _GL_EXT_ray_tracing | spirv_1_4 + _GL_EXT_ray_tracing | hlsl + _sm_6_4 +// which means it requires the `_GL_EXT_ray_tracing` extension when generating code for glsl +// or spirv, and requires sm_6_4 when generating hlsl. +// +// There are three types of capability definitions: +// - `def`: this will introduce an new capability atom. If there is an inheritance clause, +// the capability name will expand to all inherited atoms plus the newly introduced atom. +// - `abstract`: an abstract capability does not introduce an actual atom, but it defines +// an implicit conflict group such that two capabilities inheriting the same abstract +// capability cannot be satisfied simultaneously. When used in an expression, `abstract` +// capability also expands into a disjunction (or) of all inherited capabilities. +// - `alias`: this defines an alias and does not introduce actual atoms. + +// Several capabilities represent the target formats in which we generate code. +// Because we can only generate code in one format at a time, all of these are +// marked as conflicting with one another along the `TargetFormat` axis. +// +// Note: We are only including here the source code formats we initially generate +// code in and not the formats that code might be translated into "downstream." +// Trying to figure out how to integrate both kinds of formats into our capability +// system will be an interesting challenge (e.g., can we compile code for `hlsl+spirv` +// and for `glsl+spirv` or even just for `spirv`, and how should all of those impact +// overloading). +// +def textualTarget; + +abstract target; +def hlsl : target + textualTarget; +def glsl : target + textualTarget; +def c : target + textualTarget; +def cpp : target + textualTarget; +def cuda : target + textualTarget; + +// We have multiple capabilities for the various SPIR-V versions, +// arranged so that they inherit from one another to represent which versions +// provide a super-set of the features of earlier ones (e.g., SPIR-V 1.4 is +// expressed as inheriting from SPIR-V 1.3). +// +def spirv_1_0 : target; +def spirv_1_1 : spirv_1_0; +def spirv_1_2 : spirv_1_1; +def spirv_1_3 : spirv_1_2; +def spirv_1_4 : spirv_1_3; +def spirv_1_5 : spirv_1_4; +def spirv_1_6 : spirv_1_5; +alias spirv = spirv_1_0; +alias spirv_latest = spirv_1_6; + +// Capabilities that stand for target spirv version for GLSL backend. +// These are not compilation targets. +def glsl_spirv_1_0; +def glsl_spirv_1_1 : glsl_spirv_1_0; +def glsl_spirv_1_2 : glsl_spirv_1_1; +def glsl_spirv_1_3 : glsl_spirv_1_2; +def glsl_spirv_1_4 : glsl_spirv_1_3; +def glsl_spirv_1_5 : glsl_spirv_1_4; +def glsl_spirv_1_6 : glsl_spirv_1_5; + +abstract stage; +def vertex : stage; +def fragment : stage; +alias pixel = fragment; +def compute : stage; +def hull : stage; +def domain : stage; +def geometry : stage; +def raygen : stage; +def intersection : stage; +def anyhit : stage; +def closesthit: stage; +def miss : stage; +def mesh : stage; + +def _sm_5_1 : hlsl; +def _sm_6_0 : _sm_5_1; +def _sm_6_1 : _sm_6_0; +def _sm_6_2 : _sm_6_1; +def _sm_6_3 : _sm_6_2; +def _sm_6_4 : _sm_6_3; +def _sm_6_5 : _sm_6_4; +def _sm_6_6 : _sm_6_5; +def _sm_6_7 : _sm_6_6; + +// The following capabilities all pertain to how ray tracing shaders are translated +// to GLSL, where there are two different extensions that can provide the core +// functionality of `TraceRay` and the related operations. +// +// The two extensions are expressed as distinct capabilities that both are marked +// as conflicting on the `RayTracingExtension` axis, so that a compilation target +// cannot have both enabled at once. +// +// The `GL_EXT_ray_tracing` extension should be favored, so it has a rank of `1` +// instead of `0`, which means that when comparing overloads that require these +// extensions, the `EXT` extension will be favored over the `NV` extension, if +// all other factors are equal. +// +def _GL_EXT_ray_tracing : glsl + glsl_spirv_1_4 = 1; +def _GL_NV_ray_tracing : _GL_EXT_ray_tracing; +def _SPV_KHR_ray_tracing : spirv_1_4; +alias GL_NV_ray_tracing = _GL_NV_ray_tracing | _SPV_KHR_ray_tracing | _sm_6_4 | cuda; +alias GL_EXT_ray_tracing = _GL_EXT_ray_tracing | _SPV_KHR_ray_tracing | _sm_6_4 | cuda; +alias raytracing = GL_EXT_ray_tracing; + +def _GL_EXT_fragment_shader_barycentric : glsl + fragment; +def _GL_NV_fragment_shader_barycentric : _GL_EXT_fragment_shader_barycentric; +def _SPV_KHR_fragment_shader_barycentric : spirv_1_0 + fragment; +alias GL_NV_fragment_shader_barycentric = _GL_NV_fragment_shader_barycentric | _SPV_KHR_fragment_shader_barycentric | hlsl + fragment; +alias GL_EXT_fragment_shader_barycentric = _GL_EXT_fragment_shader_barycentric | _SPV_KHR_fragment_shader_barycentric | hlsl + fragment; + +// TODO: define what SM means for all supported targets. + +alias sm_5_1 = _sm_5_1; +alias sm_6_0 = _sm_6_0; +alias sm_6_1 = _sm_6_1; +alias sm_6_2 = _sm_6_2; +alias sm_6_3 = _sm_6_3; +alias sm_6_4 = _sm_6_4 | raytracing; +alias sm_6_5 = _sm_6_5; +alias sm_6_6 = _sm_6_6; +alias sm_6_7 = _sm_6_7; diff --git a/source/slang/slang-capability-defs.h b/source/slang/slang-capability-defs.h deleted file mode 100644 index c523d9cda..000000000 --- a/source/slang/slang-capability-defs.h +++ /dev/null @@ -1,103 +0,0 @@ -// slang-capability-defs.h - -// This file uses macros to define the capability "atoms" that -// are used by the `CapabilitySet` implementation. -// -// Any file that `#include`s this file is required to set -// the `SLANG_CAPABILITY_ATOM` macro before including it. -// -#ifndef SLANG_CAPABILITY_ATOM -#error Must define SLANG_CAPABILITY_ATOM before including. -#endif -// -// It is not necessary to `#undef` the macro in the client -// file, because this file will `#undef` it at the end. - -// Our representation allows each capability atom to define -// a number of other base atoms that it "inherits" from. -// -// Different atoms will need different numbers of bases, -// so we will define a few different macros that wrap -// `SLANG_CAPABILITY_ATOM` and let us handle the cases -// more conveniently. -// -// TODO: There is probably a way to handle this with -// variadic macros. -// -#define SLANG_CAPABILITY_ATOM4(ENUMERATOR, NAME, KIND, CONFLICTS, RANK, BASE0, BASE1, BASE2, BASE3) \ - SLANG_CAPABILITY_ATOM(ENUMERATOR, NAME, KIND, CONFLICTS, RANK, BASE0, BASE1, BASE2, BASE3) - -#define SLANG_CAPABILITY_ATOM3(ENUMERATOR, NAME, KIND, CONFLICTS, RANK, BASE0, BASE1, BASE2) \ - SLANG_CAPABILITY_ATOM(ENUMERATOR, NAME, KIND, CONFLICTS, RANK, BASE0, BASE1, BASE2, Invalid) - -#define SLANG_CAPABILITY_ATOM2(ENUMERATOR, NAME, KIND, CONFLICTS, RANK, BASE0, BASE1) \ - SLANG_CAPABILITY_ATOM(ENUMERATOR, NAME, KIND, CONFLICTS, RANK, BASE0, BASE1, Invalid, Invalid) - -#define SLANG_CAPABILITY_ATOM1(ENUMERATOR, NAME, KIND, CONFLICTS, RANK, BASE0) \ - SLANG_CAPABILITY_ATOM(ENUMERATOR, NAME, KIND, CONFLICTS, RANK, BASE0, Invalid, Invalid, Invalid) - -#define SLANG_CAPABILITY_ATOM0(ENUMERATOR, NAME, KIND, CONFLICTS, RANK) \ - SLANG_CAPABILITY_ATOM(ENUMERATOR, NAME, KIND, CONFLICTS, RANK, Invalid, Invalid, Invalid, Invalid) - -// Several capabilities represent the target formats in which we generate code. -// Because we can only generate code in one format at a time, all of these are -// marked as conflicting with one another along the `TargetFormat` axis. -// -// Note: We are only including here the source code formats we initially generate -// code in and not the formats that code might be translated into "downstream." -// Trying to figure out how to integrate both kinds of formats into our capability -// system will be an interesting challenge (e.g., can we compile code for `hlsl+spirv` -// and for `glsl+spirv` or even just for `spirv`, and how should all of those impact -// overloading). -// -SLANG_CAPABILITY_ATOM0(TEXTUAL_SOURCE, textual_source, Abstract,None,0) -SLANG_CAPABILITY_ATOM1(HLSL, hlsl, Concrete,TargetFormat,0,TEXTUAL_SOURCE) -SLANG_CAPABILITY_ATOM1(GLSL, glsl, Concrete,TargetFormat,0,TEXTUAL_SOURCE) -SLANG_CAPABILITY_ATOM1(C, c, Concrete,TargetFormat,0,TEXTUAL_SOURCE) -SLANG_CAPABILITY_ATOM1(CPP, cpp, Concrete,TargetFormat,0,TEXTUAL_SOURCE) -SLANG_CAPABILITY_ATOM1(CUDA, cuda, Concrete,TargetFormat,0,TEXTUAL_SOURCE) - -SLANG_CAPABILITY_ATOM0(SPIRV_DIRECT, spirv, Concrete, TargetFormat, 0) - -// We have multiple capabilities for the various SPIR-V versions, -// arranged so that they inherit from one another to represent which versions -// provide a super-set of the features of earlier ones (e.g., SPIR-V 1.4 is -// expressed as inheriting from SPIR-V 1.3). -// -SLANG_CAPABILITY_ATOM1(SPIRV, __spirv, Abstract,None,0, GLSL) -SLANG_CAPABILITY_ATOM1(SPIRV_1_0, spirv_1_0, Concrete,None,0, SPIRV) -SLANG_CAPABILITY_ATOM1(SPIRV_1_1, spirv_1_1, Concrete,None,0, SPIRV_1_0) -SLANG_CAPABILITY_ATOM1(SPIRV_1_2, spirv_1_2, Concrete,None,0, SPIRV_1_1) -SLANG_CAPABILITY_ATOM1(SPIRV_1_3, spirv_1_3, Concrete,None,0, SPIRV_1_2) -SLANG_CAPABILITY_ATOM1(SPIRV_1_4, spirv_1_4, Concrete,None,0, SPIRV_1_3) -SLANG_CAPABILITY_ATOM1(SPIRV_1_5, spirv_1_5, Concrete,None,0, SPIRV_1_4) - -// The following capabilities all pertain to how ray tracing shaders are translated -// to GLSL, where there are two different extensions that can provide the core -// functionality of `TraceRay` and the related operations. -// -// The two extensions are expressed as distinct capabilities that both are marked -// as conflicting on the `RayTracingExtension` axis, so that a compilation target -// cannot have both enabled at once. -// -// The `GL_EXT_ray_tracing` extension should be favored, so it has a rank of `1` -// instead of `0`, which means that when comparing overloads that require these -// extensions, the `EXT` extension will be favored over the `NV` extension, if -// all other factors are equal. -// -SLANG_CAPABILITY_ATOM1(GLSLRayTracing, __glslRayTracing, Abstract,None,0, GLSL) -SLANG_CAPABILITY_ATOM1(GL_NV_ray_tracing, GL_NV_ray_tracing, Concrete,RayTracingExtension,0, GLSLRayTracing) -SLANG_CAPABILITY_ATOM2(GL_EXT_ray_tracing, GL_EXT_ray_tracing, Concrete,RayTracingExtension,1, GLSLRayTracing, SPIRV_1_4) - -SLANG_CAPABILITY_ATOM1(GLSLFragmentShaderBarycentric, __glslFragmentShaderBarycentric, Abstract, None, 0, GLSL) -SLANG_CAPABILITY_ATOM1(GL_NV_fragment_shader_barycentric, GL_NV_fragment_shader_barycentric, Concrete, FragmentShaderBarycentricExtension, 0, GLSLFragmentShaderBarycentric) -SLANG_CAPABILITY_ATOM1(GL_EXT_fragment_shader_barycentric, GL_EXT_fragment_shader_barycentric, Concrete, FragmentShaderBarycentricExtension, 1, GLSLFragmentShaderBarycentric) - - -#undef SLANG_CAPABILITY_ATOM0 -#undef SLANG_CAPABILITY_ATOM1 -#undef SLANG_CAPABILITY_ATOM2 -#undef SLANG_CAPABILITY_ATOM3 -#undef SLANG_CAPABILITY_ATOM4 - -#undef SLANG_CAPABILITY_ATOM diff --git a/source/slang/slang-capability.cpp b/source/slang/slang-capability.cpp index 28dea8d23..a3f8157e7 100644 --- a/source/slang/slang-capability.cpp +++ b/source/slang/slang-capability.cpp @@ -14,7 +14,7 @@ namespace Slang // We are going to divide capability atoms into a few categories. // -enum class CapabilityAtomFlavor : int32_t +enum class CapabilityNameFlavor : int32_t { // A concrete capability atom is something that a target // can directly support, where the presence of the feature @@ -42,102 +42,68 @@ enum class CapabilityAtomFlavor : int32_t Alias, }; -// Certain capability atoms will conflict with one another, -// such that a concrete target should never be able to support -// both. -// -// It is possible in theory to define "conflicting" capabilities -// in terms of the inheritance graph, but that makes checking -// for conflicts more difficult. -// -// Instead, we are going to allow each capability to define a -// mask to indicate group(s) of conflicting capabilities it -// belongs to. Two different capability atoms that have -// overlapping masks will be considered to conflict. -// -enum class CapabilityAtomConflictMask : uint32_t -{ - // By default, most capability atoms do not conflict with one another. - None = 0, - - // Capability atoms that reprsent target code generation formats always conflict. - // (e.g., you cannot generate both HLSL and C++ output at once) - TargetFormat = 1 << 0, - - // Capability atoms that represent GLSL ray tracing extensions conflict with - // one another (we only want to use one such extension at a time). - RayTracingExtension = 1 << 1, - - // Capability atoms that represent GLSL fragment shader barycentric extensions conflict with - // one another (we only want to use one such extension at a time). - FragmentShaderBarycentricExtension = 1 << 2, -}; - -// For simplicity in building up our data structure representing -// all capability atoms, we will limit the number of bases that -// a capability atom is allowed to inherit from. -// -static const int kCapabilityAtom_MaxBases = 4; - // The macros in the `slang-capability-defs.h` file will be used // to fill out a `static const` array of information about each // capability atom. // struct CapabilityAtomInfo { - /// The API-/language-exposed name of the capability. - char const* name; + /// The API-/language-exposed name of the capability. + char const* name; - /// Flavor of atom: concrete, abstract, or alias - CapabilityAtomFlavor flavor; + /// Flavor of atom: concrete, abstract, or alias + CapabilityNameFlavor flavor; - /// A mask to indicate which other categories of atoms this one conflicts with - CapabilityAtomConflictMask conflictMask; + /// If the atom is a direct descendent of an abstract base, keep that for reference here. + CapabilityName abstractBase; - /// Ranking to use when deciding if this atom is a "better" one to select. + /// Ranking to use when deciding if this atom is a "better" one to select. uint32_t rank; - /// Base atoms this one "inherits" from (terminated with `Invalid` if not all entries used). - CapabilityAtom bases[kCapabilityAtom_MaxBases]; + /// Canonical representation in the form of disjunction-of-conjunction of atoms. + ArrayView<ArrayView<CapabilityName>> canonicalRepresentation; }; -// -static const CapabilityAtomInfo kCapabilityAtoms[Int(CapabilityAtom::Count)] = -{ - { "invalid", CapabilityAtomFlavor::Concrete, CapabilityAtomConflictMask::None, 0, { CapabilityAtom::Invalid, CapabilityAtom::Invalid, CapabilityAtom::Invalid, CapabilityAtom::Invalid } }, -#define SLANG_CAPABILITY_ATOM(ENUMERATOR, NAME, FLAVOR, CONFLICT, RANK, BASE0, BASE1, BASE2, BASE3) \ - { #NAME, CapabilityAtomFlavor::FLAVOR, CapabilityAtomConflictMask::CONFLICT, RANK, { CapabilityAtom::BASE0, CapabilityAtom::BASE1, CapabilityAtom::BASE2, CapabilityAtom::BASE3 } }, -#include "slang-capability-defs.h" -}; +#include "slang-generated-capability-defs-impl.h" - /// Get the extended information structure for the given capability `atom` +static CapabilityAtom asAtom(CapabilityName name) +{ + SLANG_ASSERT((CapabilityAtom)name < CapabilityAtom::Count); + return (CapabilityAtom)name; +} + +/// Get the extended information structure for the given capability `atom` +static CapabilityAtomInfo const& _getInfo(CapabilityName atom) +{ + SLANG_ASSERT(Int(atom) < Int(CapabilityName::Count)); + return kCapabilityNameInfos[Int(atom)]; +} static CapabilityAtomInfo const& _getInfo(CapabilityAtom atom) { SLANG_ASSERT(Int(atom) < Int(CapabilityAtom::Count)); - return kCapabilityAtoms[Int(atom)]; + return kCapabilityNameInfos[Int(atom)]; } -void getCapabilityAtomNames(List<UnownedStringSlice>& ioNames) +void getCapabilityNames(List<UnownedStringSlice>& ioNames) { - ioNames.setCount(Count(CapabilityAtom::Count)); - for (Index i = 0; i < Count(CapabilityAtom::Count); ++i) + ioNames.reserve(Count(CapabilityName::Count)); + for (Index i = 0; i < Count(CapabilityName::Count); ++i) { - ioNames[i] = UnownedStringSlice(_getInfo(CapabilityAtom(i)).name); + if (_getInfo(CapabilityName(i)).flavor != CapabilityNameFlavor::Abstract) + { + ioNames.add(UnownedStringSlice(_getInfo(CapabilityName(i)).name)); + } } } -CapabilityAtom findCapabilityAtom(UnownedStringSlice const& name) +bool lookupCapabilityName(const UnownedStringSlice& str, CapabilityName& value); + +CapabilityName findCapabilityName(UnownedStringSlice const& name) { - // For now we are implementing a linear search over the - // array of capability atoms to perform name lookup. - // - for( Index i = 0; i < Index(CapabilityAtom::Count); ++i ) - { - auto& capInfo = _getInfo(CapabilityAtom(i)); - if(name == UnownedTerminatedStringSlice(capInfo.name)) - return CapabilityAtom(i); - } - return CapabilityAtom::Invalid; + CapabilityName result; + if (!lookupCapabilityName(name, result)) + return CapabilityName::Invalid; + return result; } bool isCapabilityDerivedFrom(CapabilityAtom atom, CapabilityAtom base) @@ -147,29 +113,22 @@ bool isCapabilityDerivedFrom(CapabilityAtom atom, CapabilityAtom base) return true; } - const auto& info = kCapabilityAtoms[Index(atom)]; - - for (auto cur : info.bases) + const auto& info = kCapabilityNameInfos[Index(atom)]; + for (auto cur : info.canonicalRepresentation) { - if (cur == CapabilityAtom::Invalid) - { - return false; - } - - if (isCapabilityDerivedFrom(cur, base)) - { - return true; - } + for (auto cbase : cur) + if (asAtom(cbase) == base) + return true; } return false; } // -// CapabilitySet +// CapabilityConjunctionSet // -// The current design choice in `CapabilitySet` is that it stores +// The current design choice in `CapabilityConjunctionSet` is that it stores // an expanded, deduplicated, and sorted list of the capability // atoms in the set. "Expanded" here means that it includes the // transitive closure of the inheritance graph of those atoms. @@ -179,90 +138,64 @@ bool isCapabilityDerivedFrom(CapabilityAtom atom, CapabilityAtom base) // binary searches to efficiently detect whether an atom // is present in a set. -CapabilitySet::CapabilitySet() +CapabilityConjunctionSet::CapabilityConjunctionSet() {} -CapabilitySet::CapabilitySet(Int atomCount, CapabilityAtom const* atoms) +CapabilityConjunctionSet::CapabilityConjunctionSet(Int atomCount, CapabilityAtom const* atoms) { _init(atomCount, atoms); } -CapabilitySet::CapabilitySet(CapabilityAtom atom) +CapabilityConjunctionSet::CapabilityConjunctionSet(CapabilityAtom atom) { _init(1, &atom); } -CapabilitySet::CapabilitySet(List<CapabilityAtom> const& atoms) +CapabilityConjunctionSet::CapabilityConjunctionSet(List<CapabilityAtom> const& atoms) { _init(atoms.getCount(), atoms.getBuffer()); } -CapabilitySet CapabilitySet::makeEmpty() +CapabilityConjunctionSet CapabilityConjunctionSet::makeEmpty() { - return CapabilitySet(); + return CapabilityConjunctionSet(); } -CapabilitySet CapabilitySet::makeInvalid() +CapabilityConjunctionSet CapabilityConjunctionSet::makeInvalid() { // An invalid capability set will always be a singleton // set of the `Invalid` atom, and we will construct // the set directly rather than use the more expensive // logic in `_init()`. // - CapabilitySet result; + CapabilityConjunctionSet result; result.m_expandedAtoms.add(CapabilityAtom::Invalid); return result; } - /// Helper routine for `CapabilitySet::_init`. - /// - /// Recursively add all atoms implied by `atom` to `ioExpandedAtoms`. - /// -static void _addAtomsRec( - CapabilityAtom atom, - HashSet<CapabilityAtom>& ioExpandedAtoms) +void CapabilityConjunctionSet::_init(Int atomCount, CapabilityAtom const* atoms) { - auto& atomInfo = _getInfo(atom); - - // The first step is to add `atom` itself, *unless* - // it is an alias, because an alias shouldn't impact - // whether one set is considered a subset/superset of - // another. - // - if(atomInfo.flavor != CapabilityAtomFlavor::Alias) - { - ioExpandedAtoms.add(atom); - } - - // Next we add all the atoms transitively implied by `atom`. - // - for(auto baseAtom : atomInfo.bases) - { - // Note: the list of `bases` is a fixed-size array, but - // can be terminated with `Invalid` to indicate that - // not all of the entries are being used. - // - // If we see the sentinel, then we know we are at the end - // of the list. - // - if(baseAtom == CapabilityAtom::Invalid) - break; - - _addAtomsRec(baseAtom, ioExpandedAtoms); - } -} - -void CapabilitySet::_init(Int atomCount, CapabilityAtom const* atoms) -{ - // In order to fill in the expanded and deduplicated - // set of atoms, we will use an explicit hash set - // and then recursively walk the tree of atoms and - // their bases. + // We will use an explicit hash set to deduplicate input atoms. // HashSet<CapabilityAtom> expandedAtomsSet; for(Int i = 0; i < atomCount; ++i) { - _addAtomsRec(atoms[i], expandedAtomsSet); + if (expandedAtomsSet.add(atoms[i])) + { + auto& info = _getInfo(atoms[i]); + + // Add the base items that this atom implies. + if (info.canonicalRepresentation.getCount() == 1) + { + // The atom must have only one conjunction. + SLANG_ASSERT(info.canonicalRepresentation.getCount() == 1); + + for (auto base : info.canonicalRepresentation[0]) + { + expandedAtomsSet.add(asAtom(base)); + } + } + } } // We can then translate the set of atoms into a list, @@ -276,7 +209,7 @@ void CapabilitySet::_init(Int atomCount, CapabilityAtom const* atoms) m_expandedAtoms.sort(); } -void CapabilitySet::calcCompactedAtoms(List<CapabilityAtom>& outAtoms) const +void CapabilityConjunctionSet::calcCompactedAtoms(List<CapabilityAtom>& outAtoms) const { // A "compacted" list of atoms is one that starts with // the "expanded" list and removes any atoms that are @@ -294,13 +227,18 @@ void CapabilitySet::calcCompactedAtoms(List<CapabilityAtom>& outAtoms) const for( auto atom : m_expandedAtoms ) { auto& atomInfo = _getInfo(atom); - for(auto baseAtom : atomInfo.bases) + if (atomInfo.canonicalRepresentation.getCount() != 1) { - // Note: dealing with possible early termination of the `bases` list. - if(baseAtom == CapabilityAtom::Invalid) - break; + // If the atom is not a single conjunction, skip. + continue; + } + for(auto baseAtom : atomInfo.canonicalRepresentation[0]) + { + // Note: don't add atom itself into redundant set. + if(asAtom(baseAtom) == atom) + continue; - redundantAtomsSet.add(baseAtom); + redundantAtomsSet.add(asAtom(baseAtom)); } } @@ -318,7 +256,7 @@ void CapabilitySet::calcCompactedAtoms(List<CapabilityAtom>& outAtoms) const } } -bool CapabilitySet::isEmpty() const +bool CapabilityConjunctionSet::isEmpty() const { // Checking if a capability set is empty is trivial in any representation; // all we need to know is if it has zero atoms in its definition. @@ -326,7 +264,7 @@ bool CapabilitySet::isEmpty() const return m_expandedAtoms.getCount() == 0; } -bool CapabilitySet::isInvalid() const +bool CapabilityConjunctionSet::isInvalid() const { // We will assume here that there is only one canonical representation of // an invalid capability set, which is a singleton set of the `Invalid` @@ -342,32 +280,47 @@ bool CapabilitySet::isInvalid() const return m_expandedAtoms[0] == CapabilityAtom::Invalid; } -bool CapabilitySet::isIncompatibleWith(CapabilityAtom that) const +bool CapabilityConjunctionSet::isIncompatibleWith(CapabilityAtom that) const { // Checking for incompatibility is complicated, and it is best // to only implement it for full (expanded) sets. // - return isIncompatibleWith(CapabilitySet(that)); + return isIncompatibleWith(CapabilityConjunctionSet(that)); } -uint32_t CapabilitySet::_calcConflictMask() const +static UIntSet _calcConflictMask(CapabilityAtom atom) +{ + UIntSet mask; + auto abstractBase = _getInfo(atom).abstractBase; + if (abstractBase != CapabilityName::Invalid) + { + mask.add((UInt)abstractBase); + } + return mask; +} + +static UIntSet _calcConflictMask(const CapabilityConjunctionSet& set) { // Given a capbility set, we want to compute the mask representing // all groups of features for which it holds a potentially-conflicting atom. // - uint32_t mask = 0; - for( auto atom : m_expandedAtoms ) + UIntSet mask; + for (auto atom : set.getExpandedAtoms()) { - mask |= uint32_t(_getInfo(atom).conflictMask); + auto abstractBase = _getInfo(atom).abstractBase; + if (abstractBase != CapabilityName::Invalid) + { + mask.add((UInt)abstractBase); + } } return mask; } -bool CapabilitySet::isIncompatibleWith(CapabilitySet const& that) const +bool CapabilityConjunctionSet::isIncompatibleWith(CapabilityConjunctionSet const& that) const { // The `this` and `that` sets are incompatible if there exists // an atom A in `this` and an atom `B` in `that` such that - // A and B are not equal, but the two have overlapping "conflict mask." + // A and B are not equal, but the two have overlapping "conflict group." // // Equivalently, we can say that the two are in conflict if // @@ -382,8 +335,8 @@ bool CapabilitySet::isIncompatibleWith(CapabilitySet const& that) const // We start by identifying the OR of the conflict masks for // all features in `this` and `that`. // - uint32_t thisMask = this->_calcConflictMask(); - uint32_t thatMask = that._calcConflictMask(); + UIntSet thisMask = _calcConflictMask(*this); + UIntSet thatMask = _calcConflictMask(that); // Note: there is a possible early-exit opportunity here if // `thisMask` and `thatMask` have no overlap: there could @@ -422,8 +375,8 @@ bool CapabilitySet::isIncompatibleWith(CapabilitySet const& that) const // include something with an overlapping mask // (we don't know what at this point in the code). // - auto thisAtomMask = uint32_t(_getInfo(thisAtom).conflictMask); - if(thisAtomMask & thatMask) + auto thisConflictMask = Slang::_calcConflictMask(thisAtom); + if(UIntSet::hasIntersection(thisConflictMask, thatMask)) return true; thisIndex++; } @@ -435,8 +388,8 @@ bool CapabilitySet::isIncompatibleWith(CapabilitySet const& that) const // // The logic here is the mirror image of the case above. // - auto thatAtomMask = uint32_t(_getInfo(thatAtom).conflictMask); - if(thatAtomMask & thisMask) + auto thatConflictMask = Slang::_calcConflictMask(thatAtom); + if(UIntSet::hasIntersection(thatConflictMask, thisMask)) return true; thatIndex++; } @@ -445,7 +398,7 @@ bool CapabilitySet::isIncompatibleWith(CapabilitySet const& that) const return false; } -bool CapabilitySet::implies(CapabilitySet const& that) const +bool CapabilityConjunctionSet::implies(CapabilityConjunctionSet const& that) const { // One capability set implies another if it is a super-set // of the other one. Think of it this way: if your target @@ -541,37 +494,19 @@ struct CapabilityAtomComparator } }; -bool CapabilitySet::implies(CapabilityAtom atom) const +bool CapabilityConjunctionSet::implies(CapabilityAtom atom) const { - // The common case here is when `atom` is not an alias. + // Every non-alias atom that `this` implies should + // be presented in the `m_expandedAtoms` list. // - if( _getInfo(atom).flavor != CapabilityAtomFlavor::Alias ) - { - // Every non-alias atom that `this` implies should - // be presented in the `m_expandedAtoms` list. - // - // Because the list is sorted, we can find out whether - // it contains `atom` with a binary search. - // - Index result = m_expandedAtoms.binarySearch(atom, CapabilityAtomComparator()); - return result >= 0; - } - else - { - // In the case where `atom` is an alias, then it won't - // appear in the expanded list, and we need to check - // whether `this` set implies everything that `atom` - // transitively inherits from. - // - // The simplest way to do that is to expand `atom` - // into the full capability set it stands for and - // check that. - // - return implies(CapabilitySet(atom)); - } + // Because the list is sorted, we can find out whether + // it contains `atom` with a binary search. + // + Index result = m_expandedAtoms.binarySearch(atom, CapabilityAtomComparator()); + return result >= 0; } -Int CapabilitySet::countIntersectionWith(CapabilitySet const& that) const +Int CapabilityConjunctionSet::countIntersectionWith(CapabilityConjunctionSet const& that) const { // The goal of this subroutine is to count the number of // elements in the intersection of `this` and `that`, @@ -626,9 +561,9 @@ Int CapabilitySet::countIntersectionWith(CapabilitySet const& that) const return intersectionCount; } -bool CapabilitySet::isBetterForTarget( - CapabilitySet const& existingCaps, - CapabilitySet const& targetCaps) +bool CapabilityConjunctionSet::isBetterForTarget( + CapabilityConjunctionSet const& existingCaps, + CapabilityConjunctionSet const& targetCaps) const { auto& candidateCaps = *this; @@ -720,14 +655,12 @@ bool CapabilitySet::isBetterForTarget( // All preceding factors being equal, we prefer // a candidate that is strictly more specialized than the other. // - // TODO: This logic has the negative effect of always preferring - // to enable optional features even if they aren't necessary. - // It would prefer the set {glsl, optionalFeature} over the set - // {glsl}, even though we might argue that a default implementaton - // that works without any optional features is "obviously" what - // the user means if they didn't enable those features. + // We want to avoid choosing the candidate that uses + // optional features if they aren't necessary. + // For example, the set {glsl, optionalFeature} should not be preferred + // over the set {glsl}, if optionalFeature isn't requested explictly. // - // TODO: The right answer is possibly that we want to partition + // The solution here is that we want to partition // `candidateCaps` and `existingCaps` into two parts: their // intersection with `targetCaps` and their difference with it. // @@ -736,8 +669,28 @@ bool CapabilitySet::isBetterForTarget( // part we'd actually wnat to favor a definition that is less // specialized. // - if(candidateCaps.implies(existingCaps)) return true; - if(existingCaps.implies(candidateCaps)) return true; + CapabilityConjunctionSet candidateCapsIntersection; + CapabilityConjunctionSet candidateCapsDifference; + for (auto atom : candidateCaps.m_expandedAtoms) + { + if (targetCaps.implies(atom)) + candidateCapsIntersection.m_expandedAtoms.add(atom); + else + candidateCapsDifference.m_expandedAtoms.add(atom); + } + CapabilityConjunctionSet existingCapsIntersection; + CapabilityConjunctionSet existingCapsDifference; + for (auto atom : existingCaps.m_expandedAtoms) + { + if (targetCaps.implies(atom)) + existingCapsIntersection.m_expandedAtoms.add(atom); + else + existingCapsDifference.m_expandedAtoms.add(atom); + } + auto scoreCandidate = candidateCapsIntersection.m_expandedAtoms.getCount() - candidateCapsDifference.m_expandedAtoms.getCount(); + auto scoreExisting = existingCapsIntersection.m_expandedAtoms.getCount() - existingCapsDifference.m_expandedAtoms.getCount(); + if (scoreCandidate != scoreExisting) + return scoreCandidate > scoreExisting; // At this point we have the problem that neither candidate // appears to be "obviously" better for the target, but we @@ -747,18 +700,15 @@ bool CapabilitySet::isBetterForTarget( // different from the other, and see if anything in either case // has a ranking that should make it be preferred. // - // TODO: This should probably *not* be considering anything that - // is implied/supported by the target. - // - auto candidateScore = candidateCaps._calcDifferenceScoreWith(existingCaps); - auto existingScore = existingCaps._calcDifferenceScoreWith(candidateCaps); + auto candidateScore = candidateCapsDifference._calcDifferenceScoreWith(existingCapsDifference); + auto existingScore = existingCapsDifference._calcDifferenceScoreWith(candidateCapsDifference); if(candidateScore != existingScore) return candidateScore > existingScore; return false; } -uint32_t CapabilitySet::_calcDifferenceScoreWith(CapabilitySet const& that) const +uint32_t CapabilityConjunctionSet::_calcDifferenceScoreWith(CapabilityConjunctionSet const& that) const { uint32_t score = 0; @@ -811,12 +761,345 @@ uint32_t CapabilitySet::_calcDifferenceScoreWith(CapabilitySet const& that) cons } -bool CapabilitySet::operator==(CapabilitySet const& other) const +bool CapabilityConjunctionSet::operator==(CapabilityConjunctionSet const& other) const +{ + return m_expandedAtoms == other.m_expandedAtoms; +} + +bool CapabilityConjunctionSet::operator<(CapabilityConjunctionSet const& that) const +{ + for (Index i = 0; i < Math::Min(m_expandedAtoms.getCount(), that.m_expandedAtoms.getCount()); i++) + { + if (m_expandedAtoms[i] < that.m_expandedAtoms[i]) + return true; + else if (m_expandedAtoms[i] > that.m_expandedAtoms[i]) + return false; + } + return m_expandedAtoms.getCount() < that.m_expandedAtoms.getCount(); +} + + +CapabilitySet::CapabilitySet() +{} + +CapabilitySet::CapabilitySet(Int atomCount, CapabilityName const* atoms) +{ + for (Int i = 0; i < atomCount; i++) + addCapability(atoms[i]); +} + +CapabilitySet::CapabilitySet(CapabilityName atom) +{ + auto info = _getInfo(atom); + for (auto conjunction : info.canonicalRepresentation) + { + CapabilityConjunctionSet set; + for (auto atomName : conjunction) + set.getExpandedAtoms().add(asAtom(atomName)); + m_conjunctions.add(_Move(set)); + } +} + +CapabilitySet::CapabilitySet(List<CapabilityName> const& atoms) +{ + for (auto atom : atoms) + addCapability(atom); +} + +CapabilitySet CapabilitySet::makeEmpty() +{ + return CapabilitySet(); +} + +CapabilitySet CapabilitySet::makeInvalid() +{ + // An invalid capability set will always be a singleton + // set of the `Invalid` atom, and we will construct + // the set directly rather than use the more expensive + // logic in `_init()`. + // + CapabilitySet result; + result.m_conjunctions.add(CapabilityConjunctionSet(CapabilityAtom::Invalid)); + return result; +} + +void CapabilitySet::addCapability(CapabilityName name) +{ + join(CapabilitySet(name)); +} + +bool CapabilitySet::isEmpty() const +{ + return m_conjunctions.getCount() == 0; +} + +bool CapabilitySet::isInvalid() const +{ + return m_conjunctions.getCount() == 1 && m_conjunctions[0].isInvalid(); +} + +bool CapabilitySet::isIncompatibleWith(CapabilityAtom other) const +{ + if (isEmpty()) + return false; + + // If all conjunctions are incompatible with the atom, then we are incompatible. + for (auto& c : m_conjunctions) + if (!c.isIncompatibleWith(other)) + return false; + return true; +} + +bool CapabilitySet::isIncompatibleWith(CapabilityName other) const +{ + if (isEmpty()) + return false; + auto otherSet = CapabilitySet(other); + return isIncompatibleWith(otherSet); +} + +bool CapabilitySet::isIncompatibleWith(CapabilityConjunctionSet const& other) const { - // TODO: We should be able to implement this more efficiently - // by scanning over the two sets in tandem. + if (isEmpty()) + return false; + + // If all conjunctions are incompatible with the atom, then we are incompatible. + for (auto& c : m_conjunctions) + if (!c.isIncompatibleWith(other)) + return false; + return true; +} + +bool CapabilitySet::isIncompatibleWith(CapabilitySet const& other) const +{ + if (isEmpty()) + return false; + if (other.isEmpty()) + return false; + + // If all conjunctions in other are incompatible with the this set, then we are incompatible. + for (auto& oc : other.m_conjunctions) + for (auto& c : m_conjunctions) + if (!c.isIncompatibleWith(oc)) + return false; + return true; +} + +bool CapabilitySet::implies(CapabilityAtom atom) const +{ + if (isEmpty()) + return false; + + for (auto& c : m_conjunctions) + if (c.implies(atom)) + return true; + + return false; +} + +bool CapabilitySet::implies(const CapabilityConjunctionSet& set) const +{ + if (isEmpty()) + return false; + + for (auto& c : m_conjunctions) + if (c.implies(set)) + return true; - return this->implies(other) && other.implies(*this); + return false; +} + +bool CapabilitySet::implies(CapabilitySet const& other) const +{ + // x implies (c | d) only if (x implies c) and (x implies d). + if (other.isEmpty()) + return true; + for (auto& c : other.m_conjunctions) + if (!implies(c)) + return false; + return true; +} + +bool CapabilitySet::operator==(CapabilitySet const& that) const +{ + return m_conjunctions == that.m_conjunctions; +} + +void CapabilitySet::calcCompactedAtoms(List<List<CapabilityAtom>>& outAtoms) const +{ + for (auto& c : m_conjunctions) + { + List<CapabilityAtom> atoms; + c.calcCompactedAtoms(atoms); + outAtoms.add(atoms); + } +} + +void CapabilitySet::join(const CapabilitySet& other) +{ + if (isEmpty() || other.isInvalid()) + { + *this = other; + return; + } + if (isInvalid()) + return; + if (other.isEmpty()) + return; + + List<CapabilityConjunctionSet> resultSet; + for (auto& thatConjunction : other.m_conjunctions) + { + for (auto& thisConjunction : m_conjunctions) + { + if (thisConjunction.isIncompatibleWith(thatConjunction)) + continue; + + CapabilityConjunctionSet conjunction; + CapabilityConjunctionSet *conjunctionToAdd = nullptr; + + // Add atoms from thatConjunction that are not existant in thisConjunction. + for (auto atom : thatConjunction.getExpandedAtoms()) + { + if (thisConjunction.getExpandedAtoms().binarySearch(atom, CapabilityAtomComparator()) == -1) + { + conjunction.getExpandedAtoms().add(atom); + } + } + + if (conjunction.getExpandedAtoms().getCount() != 0) + { + // If we find any capabilities in thatConjunction that is missing from thisConjunction, + // create a new ConjunctionSet that contains atoms from both, and add it to the disjunction set. + conjunction.getExpandedAtoms().addRange(thisConjunction.getExpandedAtoms()); + conjunction.getExpandedAtoms().sort(); + conjunctionToAdd = &conjunction; + } + else + { + // Otherwise, thisConjunction implies thatConjunction, so we just add thisConjunction to resultSet. + conjunctionToAdd = &thisConjunction; + } + // We add conjunctionToAdd to resultSet only if it does not imply any existing conjunctions. + // For example, if `resultSet` is (a), and conjunctionToAdd is (ab), then we don't want to add the conjunction + // to form (a | ab) because that would reduce to (a). + bool skipAdd = false; + for (auto& c : resultSet) + { + if (conjunctionToAdd->implies(c)) + { + skipAdd = true; + break; + } + } + if (!skipAdd) + { + // Once we added the new conjunction, any existing conjunctions that implies the new one can be + // removed. + // For example, if resultSet was (ab), and we are adding (a), the result should be just (a). + for (Index i = 0; i < resultSet.getCount();) + { + if (resultSet[i].implies(*conjunctionToAdd)) + { + resultSet.fastRemoveAt(i); + } + else + { + i++; + } + } + resultSet.add(*conjunctionToAdd); + } + } + } + m_conjunctions = _Move(resultSet); + + // Make sure conjunctions are sorted so equality tests are trivial. + m_conjunctions.sort(); +} + +bool CapabilitySet::isBetterForTarget(CapabilitySet const& that, CapabilitySet const& targetCaps) const +{ + if (targetCaps.isIncompatibleWith(*this)) + return false; + if (targetCaps.isIncompatibleWith(that)) + return true; + + ArrayView<CapabilityConjunctionSet> thisSets = m_conjunctions.getArrayView(); + ArrayView<CapabilityConjunctionSet> thatSets = that.m_conjunctions.getArrayView(); + CapabilityConjunctionSet emtpySet = CapabilityConjunctionSet::makeEmpty(); + + if (isEmpty()) + thisSets = makeArrayViewSingle(emtpySet); + if (that.isEmpty()) + thatSets = makeArrayViewSingle(emtpySet); + + // It is hard to think about what it means exactly to compare a general disjunction set to another with regard + // to a target that itself is also a disjunction set. + // Instead of trying to find a meaning for the general case, we just want to extend the logic + // for conjunction sets to disjunction sets in a way that common situations are handled correctly. + // Note that when we reach here, most of these sets are likely to contain only one conjunction, so + // we just need to make sure the more general logic here yields correct result for that case. + // + // Right now, we define betterness for disjunctions as follows: + // A capability set X is determined to be better for a target T than capability set Y, + // if we find a conjunction A in X and a conjunction B in Y and a conjunction C in T such that + // A is better then B for target C. + // + struct ViableConjunctionIndex + { + Index index; + UIntSet targetConjunctionIndices; + }; + auto getViableConjunction = [&](ArrayView<CapabilityConjunctionSet> set, List<ViableConjunctionIndex>& outList) + { + for (Index i = 0; i < set.getCount(); i++) + { + auto& conjunction = set[i]; + ViableConjunctionIndex viableConjunction; + viableConjunction.index = i; + for (Index j = 0; j < targetCaps.m_conjunctions.getCount(); j++) + { + auto& targetConjunction = targetCaps.m_conjunctions[j]; + if (conjunction.isIncompatibleWith(targetConjunction)) + continue; + viableConjunction.targetConjunctionIndices.add(j); + } + if (!viableConjunction.targetConjunctionIndices.isEmpty()) + { + outList.add(viableConjunction); + } + } + }; + List<ViableConjunctionIndex> viableConjunctionsThis; + List<ViableConjunctionIndex> viableConjunctionsThat; + + getViableConjunction(thisSets, viableConjunctionsThis); + getViableConjunction(thatSets, viableConjunctionsThat); + + for (auto& thisConjunctionIndex : viableConjunctionsThis) + { + auto& thisConjunction = thisSets[thisConjunctionIndex.index]; + for (auto& thatConjunctionIndex : viableConjunctionsThat) + { + auto& thatConjunction = thatSets[thatConjunctionIndex.index]; + UIntSet intersection = thisConjunctionIndex.targetConjunctionIndices; + intersection.intersectWith(thatConjunctionIndex.targetConjunctionIndices); + if (!intersection.isEmpty()) + { + for (Index targetConjunctionIndex = 0; targetConjunctionIndex < targetCaps.m_conjunctions.getCount(); targetConjunctionIndex++) + { + if (!intersection.contains((UInt)targetConjunctionIndex)) + continue; + if (thisConjunction.isBetterForTarget(thatConjunction, targetCaps.m_conjunctions[targetConjunctionIndex])) + { + return true; + } + } + } + } + } + return false; } } diff --git a/source/slang/slang-capability.h b/source/slang/slang-capability.h index 55c5044ed..e686ff5a9 100644 --- a/source/slang/slang-capability.h +++ b/source/slang/slang-capability.h @@ -25,22 +25,7 @@ namespace Slang // the `CapabilityAtom` enumeration, which is generated from declarations // in the `slang-capability-defs.h` file. // -enum class CapabilityAtom : int32_t -{ - // The "invalid" capability represents an atomic feature that no - // platform can/will ever support. If we ever determine that a - // function needs the invalid capability, it would be reasonable - // to report that situation as an error. - // - Invalid = 0, - -#define SLANG_CAPABILITY_ATOM(ENUMERATOR, NAME, FLAVOR, CONFLICT, RANK, BASE0, BASE1, BASE2, BASE3) \ - ENUMERATOR, - -#include "slang-capability-defs.h" - - Count, -}; +#include "slang-generated-capability-defs.h" // Once we have a universe of suitable capability atoms, we can define // the capabilities of a target as simply the set of all atomic capabilities @@ -62,26 +47,31 @@ enum class CapabilityAtom : int32_t // In all cases, we represent a set of capabilities with `CapabilitySet`. /// A set of capabilities, representing features that are either supported or required -struct CapabilitySet +struct CapabilityConjunctionSet { public: /// Default-construct an empty capability set - CapabilitySet(); + CapabilityConjunctionSet(); + + CapabilityConjunctionSet(CapabilityConjunctionSet const& other) = default; + CapabilityConjunctionSet& operator=(CapabilityConjunctionSet const& other) = default; + CapabilityConjunctionSet(CapabilityConjunctionSet&& other) = default; + CapabilityConjunctionSet& operator=(CapabilityConjunctionSet&& other) = default; /// Construct a capability set from an explicit list of atomic capabilities - CapabilitySet(Int atomCount, CapabilityAtom const* atoms); + CapabilityConjunctionSet(Int atomCount, CapabilityAtom const* atoms); /// Construct a capability set from an explicit list of atomic capabilities - explicit CapabilitySet(List<CapabilityAtom> const& atoms); + explicit CapabilityConjunctionSet(List<CapabilityAtom> const& atoms); /// Construct a singleton set from a single atomic capability - explicit CapabilitySet(CapabilityAtom atom); + explicit CapabilityConjunctionSet(CapabilityAtom atom); /// Make an empty capability set - static CapabilitySet makeEmpty(); + static CapabilityConjunctionSet makeEmpty(); /// Make an invalid capability set (such that no target could ever support it) - static CapabilitySet makeInvalid(); + static CapabilityConjunctionSet makeInvalid(); /// Is this capability set empty (such that any target supports it)? bool isEmpty() const; @@ -105,7 +95,7 @@ public: bool isIncompatibleWith(CapabilityAtom other) const; /// Is this capability set incompatible with the given `other` atomic capability. - bool isIncompatibleWith(CapabilitySet const& other) const; + bool isIncompatibleWith(CapabilityConjunctionSet const& other) const; // One capability set A "implies" another set B if a target that // supports A must also support all of B. @@ -116,7 +106,7 @@ public: // and not get hung up on the set theory. /// Does this capability set imply all the capabilities in `other`? - bool implies(CapabilitySet const& other) const; + bool implies(CapabilityConjunctionSet const& other) const; /// Does this capability set imply the atomic capability `other`? bool implies(CapabilityAtom other) const; @@ -124,23 +114,24 @@ public: // A capability set is equal to another if each implies the other. /// Are these two capability sets equal? - bool operator==(CapabilitySet const& that) const; + bool operator==(CapabilityConjunctionSet const& that) const; + bool operator<(CapabilityConjunctionSet const& that) const; /// Get access to the raw atomic capabilities that define this set. List<CapabilityAtom> const& getExpandedAtoms() const { return m_expandedAtoms; } + List<CapabilityAtom>& getExpandedAtoms() { return m_expandedAtoms; } /// Calculate a list of "compacted" atoms, which excludes any atoms from the expanded list that are implies by another item in the list. void calcCompactedAtoms(List<CapabilityAtom>& outAtoms) const; - Int countIntersectionWith(CapabilitySet const& that) const; + Int countIntersectionWith(CapabilityConjunctionSet const& that) const; - bool isBetterForTarget(CapabilitySet const& that, CapabilitySet const& targetCaps); + bool isBetterForTarget(CapabilityConjunctionSet const& that, CapabilityConjunctionSet const& targetCaps) const; private: void _init(Int atomCount, CapabilityAtom const* atoms); - uint32_t _calcConflictMask() const; - uint32_t _calcDifferenceScoreWith(CapabilitySet const& other) const; + uint32_t _calcDifferenceScoreWith(CapabilityConjunctionSet const& other) const; // The underlying representation we use is a sorted and deduplicated // list of all the (non-alias) atoms that are present in the set. @@ -151,6 +142,92 @@ private: }; /// Are the `left` and `right` capability sets unequal? +inline bool operator!=(CapabilityConjunctionSet const& left, CapabilityConjunctionSet const& right) +{ + return !(left == right); +} + +struct CapabilitySet +{ +public: + /// Default-construct an empty capability set + CapabilitySet(); + + CapabilitySet(CapabilitySet const& other) = default; + CapabilitySet& operator=(CapabilitySet const& other) = default; + CapabilitySet(CapabilitySet&& other) = default; + CapabilitySet& operator=(CapabilitySet&& other) = default; + + /// Construct a capability set from an explicit list of atomic capabilities + CapabilitySet(Int atomCount, CapabilityName const* atoms); + + /// Construct a capability set from an explicit list of atomic capabilities + explicit CapabilitySet(List<CapabilityName> const& atoms); + + /// Construct a singleton set from a single atomic capability + explicit CapabilitySet(CapabilityName atom); + + /// Construct a singleton set from conjunctions + explicit CapabilitySet(const List<CapabilityConjunctionSet>& conjunctions); + + /// Make an empty capability set + static CapabilitySet makeEmpty(); + + /// Make an invalid capability set (such that no target could ever support it) + static CapabilitySet makeInvalid(); + + /// Is this capability set empty (such that any target supports it)? + bool isEmpty() const; + + /// Is this capability set invalid (such that no target could support it)? + bool isInvalid() const; + + /// Is this capability set incompatible with the given `other` set. + bool isIncompatibleWith(CapabilityAtom other) const; + + /// Is this capability set incompatible with the given `other` set. + bool isIncompatibleWith(CapabilityName other) const; + + /// Is this capability set incompatible with the given `other` atomic capability. + bool isIncompatibleWith(CapabilityConjunctionSet const& other) const; + + /// Is this capability set incompatible with the given `other` atomic capability. + bool isIncompatibleWith(CapabilitySet const& other) const; + + /// Does this capability set imply all the capabilities in `other`? + bool implies(CapabilitySet const& other) const; + + /// Does this capability set imply all the capabilities in `other`? + bool implies(CapabilityConjunctionSet const& other) const; + + /// Does this capability set imply the atomic capability `other`? + bool implies(CapabilityAtom other) const; + + /// Join two capability sets to form (this & other). + void join(const CapabilitySet& other); + + /// Are these two capability sets equal? + bool operator==(CapabilitySet const& that) const; + + /// Get access to the raw atomic capabilities that define this set. + List<CapabilityConjunctionSet>& getExpandedAtoms() { return m_conjunctions; } + const List<CapabilityConjunctionSet>& getExpandedAtoms() const { return m_conjunctions; } + + + /// Calculate a list of "compacted" atoms, which excludes any atoms from the expanded list that are implies by another item in the list. + void calcCompactedAtoms(List<List<CapabilityAtom>>& outAtoms) const; + + bool isBetterForTarget(CapabilitySet const& that, CapabilitySet const& targetCaps) const; + +private: + // The underlying representation we use is a list of conjunctions. + // + List<CapabilityConjunctionSet> m_conjunctions; + + void addCapability(CapabilityName name); +}; + +/// Are the `left` and `right` capability sets unequal? inline bool operator!=(CapabilitySet const& left, CapabilitySet const& right) { return !(left == right); @@ -160,9 +237,9 @@ inline bool operator!=(CapabilitySet const& left, CapabilitySet const& right) bool isCapabilityDerivedFrom(CapabilityAtom atom, CapabilityAtom base); /// Find a capability atom with the given `name`, or return CapabilityAtom::Invalid. -CapabilityAtom findCapabilityAtom(UnownedStringSlice const& name); +CapabilityName findCapabilityName(UnownedStringSlice const& name); /// Gets the capability names. -void getCapabilityAtomNames(List<UnownedStringSlice>& ioNames); +void getCapabilityNames(List<UnownedStringSlice>& ioNames); } diff --git a/source/slang/slang-compiler.cpp b/source/slang/slang-compiler.cpp index c2bb515f6..491655643 100644 --- a/source/slang/slang-compiler.cpp +++ b/source/slang/slang-compiler.cpp @@ -584,19 +584,23 @@ namespace Slang GLSLExtensionTracker* extensionTracker, CapabilitySet const& caps) { - for( auto atom : caps.getExpandedAtoms() ) + for( auto conjunctions : caps.getExpandedAtoms() ) { - switch( atom ) + for (auto atom : conjunctions.getExpandedAtoms()) { - default: - break; - - case CapabilityAtom::SPIRV_1_0: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 0)); break; - case CapabilityAtom::SPIRV_1_1: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 1)); break; - case CapabilityAtom::SPIRV_1_2: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 2)); break; - case CapabilityAtom::SPIRV_1_3: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 3)); break; - case CapabilityAtom::SPIRV_1_4: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 4)); break; - case CapabilityAtom::SPIRV_1_5: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 5)); break; + switch (atom) + { + default: + break; + + case CapabilityAtom::glsl_spirv_1_0: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 0)); break; + case CapabilityAtom::glsl_spirv_1_1: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 1)); break; + case CapabilityAtom::glsl_spirv_1_2: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 2)); break; + case CapabilityAtom::glsl_spirv_1_3: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 3)); break; + case CapabilityAtom::glsl_spirv_1_4: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 4)); break; + case CapabilityAtom::glsl_spirv_1_5: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 5)); break; + case CapabilityAtom::glsl_spirv_1_6: extensionTracker->requireSPIRVVersion(SemanticVersion(1, 6)); break; + } } } } diff --git a/source/slang/slang-compiler.h b/source/slang/slang-compiler.h index 8a56df3af..a95b5a6bc 100755 --- a/source/slang/slang-compiler.h +++ b/source/slang/slang-compiler.h @@ -1620,7 +1620,7 @@ namespace Slang forceGLSLScalarBufferLayout = value; } - void addCapability(CapabilityAtom capability); + void addCapability(CapabilityName capability); bool shouldEmitSPIRVDirectly() { @@ -1666,7 +1666,7 @@ namespace Slang SlangTargetFlags targetFlags = kDefaultTargetFlags; Slang::Profile targetProfile = Slang::Profile(); FloatingPointMode floatingPointMode = FloatingPointMode::Default; - List<CapabilityAtom> rawCapabilities; + List<CapabilityName> rawCapabilities; CapabilitySet cookedCapabilities; LineDirectiveMode lineDirectiveMode = LineDirectiveMode::Default; bool dumpIntermediates = false; diff --git a/source/slang/slang-doc-markdown-writer.cpp b/source/slang/slang-doc-markdown-writer.cpp index de7695d18..77b239437 100644 --- a/source/slang/slang-doc-markdown-writer.cpp +++ b/source/slang/slang-doc-markdown-writer.cpp @@ -432,20 +432,21 @@ static DocMarkdownWriter::Requirement _getRequirementFromTargetToken(const Token return Requirement{CodeGenTarget::SPIRV, UnownedStringSlice("")}; } - const CapabilityAtom targetCap = findCapabilityAtom(targetName); + const CapabilityAtom targetCap = (CapabilityAtom)findCapabilityName(targetName); if (targetCap == CapabilityAtom::Invalid) { return Requirement{ CodeGenTarget::None, String() }; } + SLANG_ASSERT(targetCap < CapabilityAtom::Count); static const CapabilityAtom rootAtoms[] = { - CapabilityAtom::GLSL, - CapabilityAtom::HLSL, - CapabilityAtom::CUDA, - CapabilityAtom::CPP, - CapabilityAtom::C, + CapabilityAtom::glsl, + CapabilityAtom::hlsl, + CapabilityAtom::cuda, + CapabilityAtom::cpp, + CapabilityAtom::c, }; for (auto rootAtom : rootAtoms) @@ -458,23 +459,23 @@ static DocMarkdownWriter::Requirement _getRequirementFromTargetToken(const Token } } - if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::GLSL)) + if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::glsl)) { return Requirement{CodeGenTarget::GLSL, targetName}; } - else if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::HLSL)) + else if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::hlsl)) { return Requirement{ CodeGenTarget::HLSL, targetName }; } - else if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::CUDA)) + else if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::cuda)) { return Requirement{ CodeGenTarget::CUDASource, targetName }; } - else if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::CPP)) + else if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::cpp)) { return Requirement{ CodeGenTarget::CPPSource, targetName }; } - else if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::C)) + else if (isCapabilityDerivedFrom(targetCap, CapabilityAtom::c)) { return Requirement{ CodeGenTarget::CSource, targetName }; } diff --git a/source/slang/slang-emit-c-like.cpp b/source/slang/slang-emit-c-like.cpp index ba5606791..8aa550a03 100644 --- a/source/slang/slang-emit-c-like.cpp +++ b/source/slang/slang-emit-c-like.cpp @@ -1214,7 +1214,8 @@ bool CLikeSourceEmitter::shouldFoldInstIntoUseSites(IRInst* inst) case kIROp_IntLit: case kIROp_FloatLit: case kIROp_BoolLit: - case kIROp_CapabilitySet: + case kIROp_CapabilityConjunction: + case kIROp_CapabilityDisjunction: return true; // Always fold these in, because their results diff --git a/source/slang/slang-emit-glsl.cpp b/source/slang/slang-emit-glsl.cpp index 0fc54ca1f..bff82acf3 100644 --- a/source/slang/slang-emit-glsl.cpp +++ b/source/slang/slang-emit-glsl.cpp @@ -70,7 +70,7 @@ void GLSLSourceEmitter::_requireRayTracing() // the user has explicitly opted in to the `GL_NV_ray_tracing` extension // we will use that one instead. // - if( getTargetCaps().implies(CapabilityAtom::GL_NV_ray_tracing) ) + if( getTargetCaps().implies(CapabilityAtom::_GL_NV_ray_tracing) ) { m_glslExtensionTracker->requireExtension(UnownedStringSlice::fromLiteral("GL_NV_ray_tracing")); } @@ -92,7 +92,7 @@ void GLSLSourceEmitter::_requireFragmentShaderBarycentric() // the user has explicitly opted in to the `GL_NV_fragment_shader_barycentric` extension // we will use that one instead. - if( getTargetCaps().implies(CapabilityAtom::GL_NV_fragment_shader_barycentric) ) + if( getTargetCaps().implies(CapabilityAtom::_GL_NV_fragment_shader_barycentric) ) { m_glslExtensionTracker->requireExtension(UnownedStringSlice::fromLiteral("GL_NV_fragment_shader_barycentric")); } @@ -657,7 +657,7 @@ bool GLSLSourceEmitter::_emitGLSLLayoutQualifierWithBindingKinds(LayoutResourceK m_writer->emit("layout(push_constant)\n"); break; case LayoutResourceKind::ShaderRecord: - if (getTargetCaps().implies(CapabilityAtom::GL_NV_ray_tracing)) + if (getTargetCaps().implies(CapabilityAtom::_GL_NV_ray_tracing)) { m_writer->emit("layout(shaderRecordNV)\n"); } @@ -1398,7 +1398,7 @@ void GLSLSourceEmitter::emitLayoutQualifiersImpl(IRVarLayout* layout) case LayoutResourceKind::RayPayload: { - if( getTargetCaps().implies(CapabilityAtom::GL_NV_ray_tracing) ) + if( getTargetCaps().implies(CapabilityAtom::_GL_NV_ray_tracing) ) { m_writer->emit("rayPayloadInNV "); } @@ -1411,7 +1411,7 @@ void GLSLSourceEmitter::emitLayoutQualifiersImpl(IRVarLayout* layout) case LayoutResourceKind::CallablePayload: { - if( getTargetCaps().implies(CapabilityAtom::GL_NV_ray_tracing) ) + if( getTargetCaps().implies(CapabilityAtom::_GL_NV_ray_tracing) ) { m_writer->emit("callableDataInNV "); } @@ -1424,7 +1424,7 @@ void GLSLSourceEmitter::emitLayoutQualifiersImpl(IRVarLayout* layout) case LayoutResourceKind::HitAttributes: { - if( getTargetCaps().implies(CapabilityAtom::GL_NV_ray_tracing) ) + if( getTargetCaps().implies(CapabilityAtom::_GL_NV_ray_tracing) ) { m_writer->emit("hitAttributeNV "); } @@ -2421,7 +2421,7 @@ void GLSLSourceEmitter::emitSimpleTypeImpl(IRType* type) // `GL_NV_ray_tracing` using target capabilities, and will always default // to `GL_EXT_ray_tracing` otherwise. // - if( getTargetCaps().implies(CapabilityAtom::GL_NV_ray_tracing) ) + if( getTargetCaps().implies(CapabilityAtom::_GL_NV_ray_tracing) ) { // If the user has explicitly opted in to `GL_NV_ray_tracing`, // then we don't need to explicitly request the extentsion again. @@ -2509,7 +2509,7 @@ bool GLSLSourceEmitter::_maybeEmitInterpolationModifierText(IRInterpolationMode if( stage == Stage::Fragment && isInput) { _requireFragmentShaderBarycentric(); - if (getTargetCaps().implies(CapabilityAtom::GL_NV_fragment_shader_barycentric)) + if (getTargetCaps().implies(CapabilityAtom::_GL_NV_fragment_shader_barycentric)) { m_writer->emit("pervertexNV "); } @@ -2657,7 +2657,7 @@ void GLSLSourceEmitter::emitVarDecorationsImpl(IRInst* varDecl) // Special case hitObjectAttribute as is only NV currently if (decoration->getOp() == kIROp_VulkanHitObjectAttributesDecoration || - getTargetCaps().implies(CapabilityAtom::GL_NV_ray_tracing)) + getTargetCaps().implies(CapabilityAtom::_GL_NV_ray_tracing)) { m_writer->emit(toSlice("NV")); } diff --git a/source/slang/slang-emit-spirv.cpp b/source/slang/slang-emit-spirv.cpp index aa277cfba..07f8a4cd2 100644 --- a/source/slang/slang-emit-spirv.cpp +++ b/source/slang/slang-emit-spirv.cpp @@ -3161,7 +3161,7 @@ struct SPIRVEmitContext } else if (semanticName == "sv_barycentrics") { - if (m_targetRequest->getTargetCaps().implies(CapabilityAtom::GL_NV_fragment_shader_barycentric)) + if (m_targetRequest->getTargetCaps().implies(CapabilityAtom::_GL_NV_fragment_shader_barycentric)) { requireSPIRVCapability(SpvCapabilityFragmentBarycentricNV); ensureExtensionDeclaration(UnownedStringSlice("SPV_NV_fragment_shader_barycentric")); diff --git a/source/slang/slang-ir-dll-import.cpp b/source/slang/slang-ir-dll-import.cpp index 2da89ad3e..fbb473ea2 100644 --- a/source/slang/slang-ir-dll-import.cpp +++ b/source/slang/slang-ir-dll-import.cpp @@ -28,7 +28,7 @@ struct DllImportContext auto funcType = builder.getFuncType(paramCount, paramTypes, resultType); builder.setDataType(result, funcType); builder.addTargetIntrinsicDecoration( - result, CapabilitySet(CapabilityAtom::CPP), targetIntrinsic); + result, CapabilitySet(CapabilityName::cpp), targetIntrinsic); return result; } diff --git a/source/slang/slang-ir-glsl-legalize.cpp b/source/slang/slang-ir-glsl-legalize.cpp index 7bd4f77a3..4d2b12bc4 100644 --- a/source/slang/slang-ir-glsl-legalize.cpp +++ b/source/slang/slang-ir-glsl-legalize.cpp @@ -914,7 +914,7 @@ GLSLSystemValueInfo* getGLSLSystemValueInfo( else if (semanticName == "sv_barycentrics") { context->requireGLSLVersion(ProfileVersion::GLSL_450); - if (codeGenContext->getTargetCaps().implies(CapabilityAtom::GL_NV_fragment_shader_barycentric)) + if (codeGenContext->getTargetCaps().implies(CapabilityAtom::_GL_NV_fragment_shader_barycentric)) { context->requireGLSLExtension(UnownedStringSlice::fromLiteral("GL_NV_fragment_shader_barycentric")); name = "gl_BaryCoordNV"; @@ -2281,7 +2281,7 @@ static void legalizeMeshOutputParam( auto arrayName = isPerPrimitive ? "gl_MeshPrimitivesEXT" : "gl_MeshVerticesEXT"; builder->addTargetIntrinsicDecoration( meshOutputBlockType, - CapabilitySet(CapabilityAtom::GLSL), + CapabilitySet(CapabilityName::glsl), UnownedStringSlice(typeName)); builder->addImportDecoration(blockParam, UnownedStringSlice(arrayName)); if(isPerPrimitive) diff --git a/source/slang/slang-ir-inst-defs.h b/source/slang/slang-ir-inst-defs.h index 99f73b025..453fbf16d 100644 --- a/source/slang/slang-ir-inst-defs.h +++ b/source/slang/slang-ir-inst-defs.h @@ -282,7 +282,9 @@ INST(Block, block, 0, PARENT) INST(VoidLit, void_constant, 0, 0) INST_RANGE(Constant, BoolLit, VoidLit) -INST(CapabilitySet, capabilitySet, 0, HOISTABLE) +INST(CapabilityConjunction, capabilityConjunction, 0, HOISTABLE) +INST(CapabilityDisjunction, capabilityDisjunction, 0, HOISTABLE) +INST_RANGE(CapabilitySet, CapabilityConjunction, CapabilityDisjunction) INST(undefined, undefined, 0, 0) diff --git a/source/slang/slang-ir-insts.h b/source/slang/slang-ir-insts.h index 4953a5287..2a7852c1e 100644 --- a/source/slang/slang-ir-insts.h +++ b/source/slang/slang-ir-insts.h @@ -20,7 +20,7 @@ class Decl; struct IRCapabilitySet : IRInst { - IR_LEAF_ISA(CapabilitySet); + IR_PARENT_ISA(CapabilitySet); CapabilitySet getCaps(); }; @@ -4688,7 +4688,7 @@ IRTargetSpecificDecoration* findBestTargetDecoration( IRTargetSpecificDecoration* findBestTargetDecoration( IRInst* val, - CapabilityAtom targetCapabilityAtom); + CapabilityName targetCapabilityAtom); bool findTargetIntrinsicDefinition(IRInst* callee, CapabilitySet const& targetCaps, UnownedStringSlice& outDefinition); diff --git a/source/slang/slang-ir-specialize-target-switch.cpp b/source/slang/slang-ir-specialize-target-switch.cpp index fcd5ca10a..f4cb6bfa7 100644 --- a/source/slang/slang-ir-specialize-target-switch.cpp +++ b/source/slang/slang-ir-specialize-target-switch.cpp @@ -18,11 +18,11 @@ namespace Slang IRBlock* targetBlock = nullptr; for (UInt i = 0; i < targetSwitch->getCaseCount(); i++) { - auto cap = (CapabilityAtom)getIntVal(targetSwitch->getCaseValue(i)); + auto cap = (CapabilityName)getIntVal(targetSwitch->getCaseValue(i)); if (target->getTargetCaps().isIncompatibleWith(cap)) continue; CapabilitySet capSet; - if (cap == CapabilityAtom::Invalid) + if (cap == CapabilityName::Invalid) capSet = CapabilitySet::makeEmpty(); else capSet = CapabilitySet(cap); diff --git a/source/slang/slang-ir.cpp b/source/slang/slang-ir.cpp index f9a1276fe..1dbb21a0d 100644 --- a/source/slang/slang-ir.cpp +++ b/source/slang/slang-ir.cpp @@ -287,16 +287,36 @@ namespace Slang CapabilitySet IRCapabilitySet::getCaps() { - List<CapabilityAtom> atoms; - - Index count = (Index) getOperandCount(); - for(Index i = 0; i < count; ++i) + switch (getOp()) { - auto operand = cast<IRIntLit>(getOperand(i)); - atoms.add(CapabilityAtom(operand->getValue())); - } + case kIROp_CapabilityConjunction: + { + List<CapabilityName> atoms; + + Index count = (Index)getOperandCount(); + for (Index i = 0; i < count; ++i) + { + auto operand = cast<IRIntLit>(getOperand(i)); + atoms.add(CapabilityName(operand->getValue())); + } - return CapabilitySet(atoms.getCount(), atoms.getBuffer()); + return CapabilitySet(atoms.getCount(), atoms.getBuffer()); + } + break; + case kIROp_CapabilityDisjunction: + { + CapabilitySet result; + Index count = (Index) getOperandCount(); + for (Index i = 0; i < count; ++i) + { + auto operand = cast<IRCapabilitySet>(getOperand(i)); + result.getExpandedAtoms().addRange(operand->getCaps().getExpandedAtoms()); + } + return result; + } + break; + } + return CapabilitySet(); } @@ -2396,17 +2416,21 @@ namespace Slang // be a minimal list of atoms such that they will produce // the same `CapabilitySet` when expanded. - List<CapabilityAtom> compactedAtoms; + List<List<CapabilityAtom>> compactedAtoms; caps.calcCompactedAtoms(compactedAtoms); - - List<IRInst*> args; - for( auto atom : compactedAtoms ) + List<IRInst*> conjunctions; + for( auto atomConjunction : compactedAtoms ) { - args.add(getIntValue(capabilityAtomType, Int(atom))); + List<IRInst*> args; + for (auto atom : atomConjunction) + args.add(getIntValue(capabilityAtomType, Int(atom))); + auto conjunctionInst = createIntrinsicInst( + capabilitySetType, kIROp_CapabilityConjunction, args.getCount(), args.getBuffer()); + conjunctions.add(conjunctionInst); } - - return createIntrinsicInst( - capabilitySetType, kIROp_CapabilitySet, args.getCount(), args.getBuffer()); + if (conjunctions.getCount() == 1) + return conjunctions[0]; + return createIntrinsicInst(capabilitySetType, kIROp_CapabilityDisjunction, conjunctions.getCount(), conjunctions.getBuffer()); } static void canonicalizeInstOperands(IRBuilder& builder, IROp op, ArrayView<IRInst*> operands) @@ -8004,7 +8028,7 @@ namespace Slang IRTargetSpecificDecoration* findBestTargetDecoration( IRInst* val, - CapabilityAtom targetCapabilityAtom) + CapabilityName targetCapabilityAtom) { return findBestTargetDecoration(val, CapabilitySet(targetCapabilityAtom)); } diff --git a/source/slang/slang-lower-to-ir.cpp b/source/slang/slang-lower-to-ir.cpp index 4ee4efc16..f624b0baa 100644 --- a/source/slang/slang-lower-to-ir.cpp +++ b/source/slang/slang-lower-to-ir.cpp @@ -8724,7 +8724,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo> // target, and we need to reflect that at the IR level. auto targetName = targetMod->targetToken.getContent(); - auto targetCap = findCapabilityAtom(targetName); + auto targetCap = findCapabilityName(targetName); getBuilder()->addTargetDecoration(inst, CapabilitySet(targetCap)); } @@ -8777,8 +8777,8 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo> } else { - CapabilityAtom targetCap = findCapabilityAtom(targetName); - SLANG_ASSERT(targetCap != CapabilityAtom::Invalid); + CapabilityName targetCap = findCapabilityName(targetName); + SLANG_ASSERT(targetCap != CapabilityName::Invalid); targetCaps = CapabilitySet(targetCap); } @@ -8923,7 +8923,7 @@ struct DeclLoweringVisitor : DeclVisitor<DeclLoweringVisitor, LoweredValInfo> getBuilder()->addTargetIntrinsicDecoration( irInst, - CapabilitySet(CapabilityAtom::TEXTUAL_SOURCE), + CapabilitySet(CapabilityName::textualTarget), definition.getUnownedSlice() ); } diff --git a/source/slang/slang-options.cpp b/source/slang/slang-options.cpp index 9830fb18c..7c442a9d2 100644 --- a/source/slang/slang-options.cpp +++ b/source/slang/slang-options.cpp @@ -307,7 +307,7 @@ void initCommandOptions(CommandOptions& options) "code accordingly."); List<UnownedStringSlice> names; - getCapabilityAtomNames(names); + getCapabilityNames(names); // We'll just add to keep the list more simple... options.addValue("spirv_1_{ 0,1,2,3,4,5 }", "minimum supported SPIR - V version"); @@ -315,11 +315,12 @@ void initCommandOptions(CommandOptions& options) for (auto name : names) { if (name.startsWith("__") || - name.startsWith("spirv_1_")) + name.startsWith("spirv_1_") || + name.startsWith("_")) { continue; } - else if (name.startsWith("GL_")) + else if (name.startsWith("GL_") || name.startsWith("SPV_") || name.startsWith("GLSL_")) { // We'll assume it is an extension.. StringBuilder buf; @@ -764,7 +765,7 @@ struct OptionsParser int targetID = -1; FloatingPointMode floatingPointMode = FloatingPointMode::Default; bool forceGLSLScalarLayout = false; - List<CapabilityAtom> capabilityAtoms; + List<CapabilityName> capabilityAtoms; // State for tracking command-line errors bool conflictingProfilesSet = false; @@ -796,7 +797,7 @@ struct OptionsParser RawTarget* getCurrentTarget(); void setProfileVersion(RawTarget* rawTarget, ProfileVersion profileVersion); - void addCapabilityAtom(RawTarget* rawTarget, CapabilityAtom atom); + void addCapabilityAtom(RawTarget* rawTarget, CapabilityName atom); void setFloatingPointMode(RawTarget* rawTarget, FloatingPointMode mode); @@ -1161,7 +1162,7 @@ void OptionsParser::setProfileVersion(RawTarget* rawTarget, ProfileVersion profi rawTarget->profileVersion = profileVersion; } -void OptionsParser::addCapabilityAtom(RawTarget* rawTarget, CapabilityAtom atom) +void OptionsParser::addCapabilityAtom(RawTarget* rawTarget, CapabilityName atom) { rawTarget->capabilityAtoms.add(atom); } @@ -1755,8 +1756,8 @@ SlangResult OptionsParser::_parseProfile(const CommandLineArg& arg) for (Index i = 1; i < sliceCount; ++i) { UnownedStringSlice atomName = slices[i]; - CapabilityAtom atom = findCapabilityAtom(atomName); - if (atom == CapabilityAtom::Invalid) + CapabilityName atom = findCapabilityName(atomName); + if (atom == CapabilityName::Invalid) { m_sink->diagnose(operand.loc, Diagnostics::unknownProfile, atomName); return SLANG_FAIL; @@ -2119,8 +2120,8 @@ SlangResult OptionsParser::_parse( for (Index i = 0; i < sliceCount; ++i) { UnownedStringSlice atomName = slices[i]; - CapabilityAtom atom = findCapabilityAtom(atomName); - if (atom == CapabilityAtom::Invalid) + CapabilityName atom = findCapabilityName(atomName); + if (atom == CapabilityName::Invalid) { m_sink->diagnose(operand.loc, Diagnostics::unknownProfile, atomName); return SLANG_FAIL; diff --git a/source/slang/slang-parser.cpp b/source/slang/slang-parser.cpp index 62ab71430..909a8eb72 100644 --- a/source/slang/slang-parser.cpp +++ b/source/slang/slang-parser.cpp @@ -4868,8 +4868,8 @@ namespace Slang for (auto caseName : caseNames) { TargetCaseStmt* targetCase = parser->astBuilder->create<TargetCaseStmt>(); - auto cap = findCapabilityAtom(caseName.getContent()); - if (caseName.getContent().getLength() && cap == CapabilityAtom::Invalid) + auto cap = findCapabilityName(caseName.getContent()); + if (caseName.getContent().getLength() && cap == CapabilityName::Invalid) { parser->sink->diagnose(caseName.loc, Diagnostics::unknownTargetName, caseName.getContent()); } diff --git a/source/slang/slang.cpp b/source/slang/slang.cpp index 7bc73fd2c..8eb75c119 100644 --- a/source/slang/slang.cpp +++ b/source/slang/slang.cpp @@ -661,7 +661,7 @@ SLANG_NO_THROW SlangProfileID SLANG_MCALL Session::findProfile( SLANG_NO_THROW SlangCapabilityID SLANG_MCALL Session::findCapability( char const* name) { - return SlangCapabilityID(Slang::findCapabilityAtom(UnownedTerminatedStringSlice(name))); + return SlangCapabilityID(Slang::findCapabilityName(UnownedTerminatedStringSlice(name))); } SLANG_NO_THROW void SLANG_MCALL Session::setDownstreamCompilerPath( @@ -1439,9 +1439,12 @@ void Linkage::buildHash(DigestBuilder<SHA1>& builder, SlangInt targetIndex) builder.append(targetReq->shouldTrackLiveness()); auto cookedCapabilities = targetReq->getTargetCaps().getExpandedAtoms(); - for (auto& capability : cookedCapabilities) + builder.append(cookedCapabilities.getCount()); + for (auto& capabilityConjunction : cookedCapabilities) { - builder.append(capability); + builder.append(capabilityConjunction.getExpandedAtoms().getCount()); + for (auto atom : capabilityConjunction.getExpandedAtoms()) + builder.append(atom); } const PassThroughMode passThroughMode = getDownstreamCompilerRequiredForTarget(targetReq->getTarget()); @@ -1523,7 +1526,7 @@ void TargetRequest::setHLSLToVulkanLayoutOptions(HLSLToVulkanLayoutOptions* opts } } -void TargetRequest::addCapability(CapabilityAtom capability) +void TargetRequest::addCapability(CapabilityName capability) { rawCapabilities.add(capability); cookedCapabilities = CapabilitySet::makeEmpty(); @@ -1553,23 +1556,26 @@ CapabilitySet TargetRequest::getTargetCaps() // atoms, so that most of the information about what operations // are available where can be directly encoded on the declarations. - List<CapabilityAtom> atoms; + List<CapabilityName> atoms; + bool isGLSLTarget = false; switch(format) { case CodeGenTarget::GLSL: case CodeGenTarget::GLSL_Vulkan: case CodeGenTarget::GLSL_Vulkan_OneDesc: - atoms.add(CapabilityAtom::GLSL); + isGLSLTarget = true; + atoms.add(CapabilityName::glsl); break; case CodeGenTarget::SPIRV: case CodeGenTarget::SPIRVAssembly: if (targetFlags & SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY) { - atoms.add(CapabilityAtom::SPIRV_DIRECT); + atoms.add(CapabilityName::spirv_1_5); } else { - atoms.add(CapabilityAtom::GLSL); + isGLSLTarget = true; + atoms.add(CapabilityName::glsl); } break; @@ -1578,11 +1584,11 @@ CapabilitySet TargetRequest::getTargetCaps() case CodeGenTarget::DXBytecodeAssembly: case CodeGenTarget::DXIL: case CodeGenTarget::DXILAssembly: - atoms.add(CapabilityAtom::HLSL); + atoms.add(CapabilityName::hlsl); break; case CodeGenTarget::CSource: - atoms.add(CapabilityAtom::C); + atoms.add(CapabilityName::c); break; case CodeGenTarget::CPPSource: @@ -1591,19 +1597,35 @@ CapabilitySet TargetRequest::getTargetCaps() case CodeGenTarget::ShaderSharedLibrary: case CodeGenTarget::HostHostCallable: case CodeGenTarget::ShaderHostCallable: - atoms.add(CapabilityAtom::CPP); + atoms.add(CapabilityName::cpp); break; case CodeGenTarget::CUDASource: case CodeGenTarget::PTX: - atoms.add(CapabilityAtom::CUDA); + atoms.add(CapabilityName::cuda); break; default: break; } - for(auto atom : rawCapabilities) + + CapabilitySet latestSpirvCapSet = CapabilitySet(CapabilityName::spirv_latest); + CapabilityName latestSpirvAtom = (CapabilityName)latestSpirvCapSet.getExpandedAtoms()[0].getExpandedAtoms().getLast(); + for (auto atom : rawCapabilities) + { + if (isGLSLTarget) + { + // If we are emitting GLSL code, we need to + // translate all spirv_*_* capabilities to + // glsl_spirv_*_* instead. + // + if (atom >= CapabilityName::spirv_1_0 && atom <= latestSpirvAtom) + { + atom = (CapabilityName)((Int)CapabilityName::glsl_spirv_1_0 + ((Int)atom - (Int)CapabilityName::spirv_1_0)); + } + } atoms.add(atom); + } cookedCapabilities = CapabilitySet(atoms); return cookedCapabilities; @@ -5088,7 +5110,7 @@ SlangResult EndToEndCompileRequest::addTargetCapability(SlangInt targetIndex, Sl auto& targets = getLinkage()->targets; if(targetIndex < 0 || targetIndex >= targets.getCount()) return SLANG_E_INVALID_ARG; - targets[targetIndex]->addCapability(CapabilityAtom(capability)); + targets[targetIndex]->addCapability(CapabilityName(capability)); return SLANG_OK; } |