Capabilities System, CapabilitySet Logic Overhaul (#4145)

* Capabilities System, Backing Logic Overhaul

Fixes #4015

Problems to address:
1. Currently the capabilities system spends anywhere from 25-50% of compile time on the CapabilityVisitor. Most of this time is spent on join logic: 1. Finding abstract atoms 2. Comparing list1<->list2. This should and can be made significantly faster.
2. Error system does not produce errors with auxiliary information. This will require a partial redesign to provide more useful semantic information for debugging.

What was addressed:
1. Array backed `CapabilityConjunctionSet` was replaced in-favor for a `UIntSet` backed `CapabilityTargetSets`. The design is described below.
Design:
* `CapabilityTargetSets` is a `Dictionary<targetAtom, CapabilityTargetSet>`. This is not an array for 2 reasons: 1. Easy to figure out which target is missing between two `CapabilityTargetSets` 2. To statically allocate an array requires the preprocessor to manually annotate which Capability is a target and link that Capability to an index. This means a dictionary is required for lookup regardless of implementation.
* `CapabilityTargetSet` is an intermediate representation of all capabilities for a singular `target` atom (`glsl`, `hlsl`, `metal`, ...). This structure contains a dictionary to all stage specific capability sets for fast lookup of stage capabilities supported by a `CapabilitySet` for a `target` atom. This reduces number of sets searched.
* `CapabilityStageSet` is an intermediate representation of all capabilities for a singular `stage` atom (`vertex`, `fragment`, ...). This structure holds all disjoint capability sets for a `stage`. A disjoint set is rare, but may exist in some scenarios (as an example): `{glsl, EXT_GL_FOO}{glsl, _GLSL_130, _GLSL_150}`. This reduces the number of sets searched.
* `UIntSet` is the main reason for the redesign for better performance and memory usage. All set operations only require a few operations, making all set logic trivial and with minimal cost to run. All algorithms were modified to focus around `UIntSet` operations.

2. Errors
* Semantic information are now better linked to the calling function to provide a connection of function<->function_body for when saving semantic information for errors.
* Missing targets now print errors much like other error code by finding code which could be a cause of incompatibility.

What is missing:
1. Add non naive support for non-stage specific capabilities such as `{hlsl, _sm_5_0}`. Currently non stage specific targets emulate the behavior through assigning such capabilities to every stage: `{hlsl, _sm_5_0, vertex} {hlsl, _sm_5_0, fragment}...`. Removal of this behavior would remove redundant shader stage sets being made at construction time (~80% of new implementation runtime). This is an addition, not an overhaul.
2. Optionally: `UIntSet` should be modified to support SIMD operations for significantly faster operations. This is not required immediately since `UIntSet` is already not a performance constraint.

Notes:
* UIntSet had implementation bugs which were fixed in this PR.
* The old capabilities system had bugs which were fixed in this PR when transforming to the new implementation.

* fix .natvis debug view

* Small optimizations I found while working on the addition

the AST building pass looks like so now:
1% = ~capabilitySet
2% = capabilitySet()
1.5% capabilitySet::unionWith()
0.8% capabilitySet::join()
1.5% auxillary info for debugging
~0.5-1% extra visitor overhead

~5% total for the visitor
~6.5% for total runtime costs

* fix caps which were wrong but worked

* push minor syntax fix (still looking for why other tests fail)

* perf & bug fixes

1. did not properly remake isBetterForTarget for this->empty case with that as Invalid. This is best case in this senario.
2. Remade seralizer for stdlib generation. Faster (more direct) & cleaner code.

NOTE: did not address review comments

* fix glsl.meta caps error

* fixing findBest logic again & UIntSet wrapper

findBest was not checking for 'more specialized' targets & was element counter was flawed

* faster getElements algorithm + natvis for UIntSet + wrong warning

* type incompatability of bitscanForward implementations

* try to fix warnings again

* remove ptr for clang intrinsic

* add missing header

* ifdef to allow clang compile

* compiler hackery to fix up platform/type independent operations

* bracket

* fix MSVC error

* missing template

* change types out again

* changes to fix compiling

* adjustment to parameter for Clang/GCC

* added iterator to delay processing all atomSets of a CapabilitySet

* add a few missing consts's

* ensure we never have more than 1 disjointSet

Added a wrapper + assert + union functionality to all possible disjoint sets. This was done in favor of a removal of the LinkedList for 2 reasons:
1. We still need 0-1 set functionality.
2. Might as well keep the code, just disallow the problematic functionality.

* address review comments

non linked-list refactor review comments addressed; add doc comments + remove redundant code

* comments + remove isValid for bool operator

* push removal of linkedlist for capabilities

* add missing break

* address review comments

minor adjustments of syntax

* push a fix to the `CapabilitySet({shader, missing target})` code

* quality + error

1. add iterator to UIntSet
2. do not specialize target_switch if profile is derived from case (GLSL_150 is not compatable with GLSL_400)

* fix target_switch erroring + temporarily remove UIntSet::Interator

temporarily remove UIntSet::Interator. It will be added after, testing code on CI first so I can multi-task fixing the UIntSet Iterator

* fix the UIntSet iterator

* Revert "fix the UIntSet iterator" temporarily to pull from master

* add metal error as per texture.slang

(took a while I realize this was why things were breaking, likely should adjust errors to reflect this)

* Rework UIntSet to have a template for output type

This is done so it is reasonable to debug the iterator output and not just dealing with messy int's

Fix problems with the iterators implemented + invalid capabilities handling

* removed incorrect `__target_switch` capability

barycentric was being used with anticipation of `profile glsl450`, this does not expand into `GL_EXT_fragment_shader_barycentric`, this instead caused an error which is hidden during cross-compile.

* remove some uses of getElements

* remove undeclared_stage for now

* remove redundant code associated with `undeclared_stage`

* remove unused variable

* address review

specifically to note removed static in a thread dangerous scope. Now using a `const static` for read only (thread safe) which precompile steps generate

* move GLSL_150 capdef change to sm_4_1 (more accurate)

* address most review comments

did not address: https://github.com/shader-slang/slang/pull/4145#discussion_r1602256776

* revert incorrect code review suggestion

* push changes for all code review suggestions

1 files changed, 22 insertions, 8 deletions

diff --git a/source/slang/slang-ir-specialize-target-switch.cpp b/source/slang/slang-ir-specialize-target-switch.cpp
index f4cb6bfa7..fac1dd484 100644
--- a/source/slang/slang-ir-specialize-target-switch.cpp
+++ b/source/slang/slang-ir-specialize-target-switch.cpp
@@ -7,13 +7,15 @@
 
 namespace Slang
 {
-    void specializeTargetSwitch(TargetRequest* target, IRGlobalValueWithCode* code)
+    void specializeTargetSwitch(TargetRequest* target, IRGlobalValueWithCode* code, DiagnosticSink* sink)
     {
         bool changed = false;
         for (auto block : code->getBlocks())
         {
+            bool failedImplies = false;
             if (auto targetSwitch = as<IRTargetSwitch>(block->getTerminator()))
             {
+                bool isEqual;
                 CapabilitySet bestCapSet = CapabilitySet::makeInvalid();
                 IRBlock* targetBlock = nullptr;
                 for (UInt i = 0; i < targetSwitch->getCaseCount(); i++)
@@ -22,14 +24,22 @@ namespace Slang
                     if (target->getTargetCaps().isIncompatibleWith(cap))
                         continue;
                     CapabilitySet capSet;
-                    if (cap == CapabilityName::Invalid)
+                    if (cap == CapabilityName::Invalid) // `default` case
                         capSet = CapabilitySet::makeEmpty();
                     else
                         capSet = CapabilitySet(cap);
-                    if (capSet.isBetterForTarget(bestCapSet, target->getTargetCaps()))
+                    bool isBetterForTarget = capSet.isBetterForTarget(bestCapSet, target->getTargetCaps(), isEqual);
+                    if (isBetterForTarget)
                     {
-                        targetBlock = targetSwitch->getCaseBlock(i);
-                        bestCapSet = capSet;
+                        bool targetImpliesCapSet = (target->getTargetCaps().implies(capSet, true) || capSet.isEmpty());
+                        if (targetImpliesCapSet)
+                        {
+                            // Now check if bestCapSet contains targetCaps. If it does not then this is an invalid target
+                            targetBlock = targetSwitch->getCaseBlock(i);
+                            bestCapSet = capSet;
+                        }
+                        else
+                            failedImplies = true;
                     }
                 }
                 IRBuilder builder(targetSwitch);
@@ -40,6 +50,10 @@ namespace Slang
                 }
                 else
                 {
+                    // only error if we have the chance of setting a valid target switch, but did not due to incompatability within same `target` atom.
+                    // Otherwise we will have an issue when we process a `__target_switch() { case metal: return; }` for glsl targets.
+                    if(failedImplies)
+                        sink->diagnose(targetSwitch->sourceLoc, Diagnostics::profileIncompatibleWithTargetSwitch, target->getTargetCaps());
                     builder.emitMissingReturn();
                 }
                 targetSwitch->removeAndDeallocate();
@@ -53,19 +67,19 @@ namespace Slang
         }
     }
 
-    void specializeTargetSwitch(TargetRequest* target, IRModule* module)
+    void specializeTargetSwitch(TargetRequest* target, IRModule* module, DiagnosticSink* sink)
     {
         for (auto globalInst : module->getGlobalInsts())
         {
             if (auto code = as<IRGlobalValueWithCode>(globalInst))
             {
-                specializeTargetSwitch(target, code);
+                specializeTargetSwitch(target, code, sink);
                 if (auto gen = as<IRGeneric>(code))
                 {
                     auto retVal = findGenericReturnVal(gen);
                     if (auto innerCode = as<IRGlobalValueWithCode>(retVal))
                     {
-                        specializeTargetSwitch(target, innerCode);
+                        specializeTargetSwitch(target, innerCode, sink);
                     }
                 }
             }