Add generic And<T> and Or<T> methods to System.Threading.Interlocked (#120978)

## Summary

This PR adds generic versions of the `And` and `Or` methods to
`System.Threading.Interlocked` as specified in API proposal #114568.

## Changes

- [x] Add generic `And<T>(ref T, T) where T : struct` method
- [x] Add generic `Or<T>(ref T, T) where T : struct` method  
- [x] Support integer primitive types and enums backed by integer types
- [x] Reject float/double types and floating-point backed enums
- [x] Add appropriate error handling and messages
- [x] Update reference assembly
- [x] Add comprehensive theory-based tests (40+ test methods with 100+
test cases)
- [x] Replace existing usages of `Interlocked.And/Or(ref Unsafe.As...)`
with new generic API
- [x] Restrict JIT intrinsic expansion to TYP_INT and TYP_LONG only
- [x] Add TODO comment for small integer intrinsic support
- [x] Update XML documentation to clarify floating-point restrictions
- [x] Simplify validation logic to single-level if statement
- [x] Security checks (CodeQL - no issues)

## Implementation Details

- **For 1-2 byte types** (`byte`, `sbyte`, `short`, `ushort`): Uses
CompareExchange-based loop (managed fallback)
- **For 4-byte types** (`int`, `uint`): Delegates to int And/Or with
bitcast (JIT intrinsic)
- **For 8-byte types** (`long`, `ulong`): Delegates to long And/Or with
bitcast (JIT intrinsic)
- **Float/Double**: Rejected via type checks
- **Floating-point backed enums**: Rejected via
`Type.GetEnumUnderlyingType()` check (JIT-foldable)
- **JIT Integration**: Modified to only expand intrinsic for TYP_INT and
TYP_LONG; other types fall back to managed
- **Pattern**: Follows same approach as generic `CompareExchange<T>`

## JIT Changes

Modified `importercalls.cpp` to restrict intrinsic expansion:
- Only `TYP_INT` and `TYP_LONG` are expanded as atomic operations
- All other types (byte, short, float, double) fall back to managed
CompareExchange loops
- Uses `callType` consistently for type checks
- Added TODO comment: "Implement support for XAND/XORR with small
integer types (byte/short)"
- Ensures correct behavior across all supported primitive types and
enums

## Type Rejection

The methods reject:
- Non-primitive, non-enum types
- Floating-point primitives (float, double)
- Enums backed by floating-point types (via
`Type.GetEnumUnderlyingType()`)

The validation check is a single-level if statement with proper
indentation:
```cs
if ((!typeof(T).IsPrimitive && !typeof(T).IsEnum) ||
    typeof(T) == typeof(float) || typeof(T) == typeof(double) ||
    (typeof(T).IsEnum && (typeof(T).GetEnumUnderlyingType() == typeof(float) || typeof(T).GetEnumUnderlyingType() == typeof(double))))
{
    throw new NotSupportedException(SR.NotSupported_IntegerEnumOrPrimitiveTypeRequired);
}
```

## Documentation

The XML documentation clearly states the restrictions:
```cs
/// <typeparam name="T">
/// The type to be used for <paramref name="location1"/> and <paramref name="value"/>.
/// This type must be an integer primitive type or an enum type backed by an integer type.
/// Floating-point types (float, double) are not supported.
/// </typeparam>
```

## Test Coverage

Converted all tests to `[Theory]` with `[InlineData]` covering:
- **Multiple test cases per type**: 5-10 values each including edge
cases
- **Negative values**: Comprehensive coverage for all signed types
(sbyte, short, int, long)
- **Edge cases**: Min/max values, zero, all-ones, alternating bit
patterns
- **Float/Double/Half NotSupportedException tests**: Verify rejection of
floating-point types
- **Null reference exceptions**: Separate tests for all types
- **Unsupported types**: Tests for non-primitive value types

## Usages Replaced

Replaced 7 call sites across the codebase:
- `System.Private.CoreLib/ComWrappers.cs` (2 calls)
- `System.Net.Http/CacheControlHeaderValue.cs` (2 calls)
- `System.Private.Uri/Uri.cs` (1 call)
- `System.Private.Uri/UriSyntax.cs` (1 call)
- `System.Private.Uri/UriScheme.cs` (1 call)

All usages now use the cleaner generic API without `Unsafe.As` casts.

## Test Results
✅ All 705 System.Threading tests pass (0 errors, 0 failures)

## Security
✅ CodeQL analysis passed with no issues

<!-- START COPILOT CODING AGENT SUFFIX -->



<details>

<summary>Original prompt</summary>

> We have the following public APIs in `System.Threading.Interlocked`
class:
> 
> ```cs
> public static int Or(ref int location1, int value)
> public static uint Or(ref uint location1, uint value)
> public static long Or(ref long location1, long value)
> public static ulong Or(ref ulong location1, ulong value)
> 
> public static int And(ref int location1, int value)
> public static uint And(ref uint location1, uint value)
> public static long And(ref long location1, long value)
> public static ulong And(ref ulong location1, ulong value)
> ```
> We want to add their generic versions:
> ```
> public static T Or<T>(ref T location1, T value) where T : struct;
> public static T And<T>(ref T location1, T value) where T : struct;
> ```
> for the same types + enums backed by those types.
> 
> Similar to what we did for CompareExchange in
#104558.
> NOTE: this will require a bit of JIT work, e.g.
NI_System_Threading_Interlocked_Or and
NI_System_Threading_Interlocked_And
> 
> Create a PR in dotnet/runtime to add that. Effectively, implement this
API proposal: #114568


</details>



<!-- START COPILOT CODING AGENT TIPS -->
---

💡 You can make Copilot smarter by setting up custom instructions,
customizing its development environment and configuring Model Context
Protocol (MCP) servers. Learn more [Copilot coding agent
tips](https://gh.io/copilot-coding-agent-tips) in the docs.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: EgorBo <523221+EgorBo@users.noreply.github.com>
Co-authored-by: Egor Bogatov <egorbo@gmail.com>

Author: Copilot

src/coreclr/jit/importercalls.cpp

@@ -4165,16 +4165,23 @@ GenTree* Compiler::impIntrinsic(CORINFO_CLASS_HANDLE    clsHnd,
             case NI_System_Threading_Interlocked_Or:
             case NI_System_Threading_Interlocked_And:
             {
+#if defined(TARGET_X86)
+                // On x86, TYP_LONG is not supported as an intrinsic
+                if (genActualType(callType) == TYP_LONG)
+                {
+                    break;
+                }
+#endif
+                // TODO: Implement support for XAND/XORR with small integer types (byte/short)
+                if ((callType != TYP_INT) && (callType != TYP_LONG))
+                {
+                    break;
+                }
+
 #if defined(TARGET_ARM64)
                 if (compOpportunisticallyDependsOn(InstructionSet_Atomics))
 #endif
                 {
-#if defined(TARGET_X86)
-                    if (genActualType(callType) == TYP_LONG)
-                    {
-                        break;
-                    }
-#endif
                     assert(sig->numArgs == 2);
                     GenTree*   op2 = impPopStack().val;
                     GenTree*   op1 = impPopStack().val;

src/libraries/System.Net.Http/src/System/Net/Http/Headers/CacheControlHeaderValue.cs

@@ -70,11 +70,11 @@ private void SetFlag(Flags flag, bool value)
             // that concurrent modifications of different properties don't interfere with each other.
             if (value)
             {
-                Interlocked.Or(ref Unsafe.As<Flags, int>(ref _flags), (int)flag);
+                Interlocked.Or(ref _flags, flag);
             }
             else
             {
-                Interlocked.And(ref Unsafe.As<Flags, int>(ref _flags), (int)~flag);
+                Interlocked.And(ref _flags, ~flag);
             }
         }
 

src/libraries/System.Private.CoreLib/src/Resources/Strings.resx

@@ -4388,6 +4388,9 @@
   <data name="NotSupported_ReferenceEnumOrPrimitiveTypeRequired" xml:space="preserve">
     <value>The specified type must be a reference type, a primitive type, or an enum type.</value>
   </data>
+  <data name="NotSupported_IntegerEnumOrPrimitiveTypeRequired" xml:space="preserve">
+    <value>The specified type must be an integer primitive type or an enum type.</value>
+  </data>
   <data name="Argument_BadFieldForInitializeArray" xml:space="preserve">
     <value>The field is invalid for initializing array or span.</value>
   </data>

src/libraries/System.Private.CoreLib/src/System/Runtime/InteropServices/ComWrappers.cs

@@ -444,14 +444,12 @@ private IntPtr AsUserDefined(in Guid riid)
 
             private void SetFlag(CreateComInterfaceFlagsEx flag)
             {
-                int setMask = (int)flag;
-                Interlocked.Or(ref Unsafe.As<CreateComInterfaceFlagsEx, int>(ref Flags), setMask);
+                Interlocked.Or(ref Flags, flag);
             }
 
             private void ResetFlag(CreateComInterfaceFlagsEx flag)
             {
-                int resetMask = ~(int)flag;
-                Interlocked.And(ref Unsafe.As<CreateComInterfaceFlagsEx, int>(ref Flags), resetMask);
+                Interlocked.And(ref Flags, ~flag);
             }
 
             private static uint GetTrackerCount(ulong c)

src/libraries/System.Private.CoreLib/src/System/Threading/Interlocked.cs

@@ -634,6 +634,83 @@ public static long And(ref long location1, long value)
         [CLSCompliant(false)]
         public static ulong And(ref ulong location1, ulong value) =>
             (ulong)And(ref Unsafe.As<ulong, long>(ref location1), (long)value);
+
+        /// <summary>Bitwise "ands" two values of type <typeparamref name="T"/> and replaces the first value with the result, as an atomic operation.</summary>
+        /// <param name="location1">A variable containing the first value to be combined. The result is stored in <paramref name="location1"/>.</param>
+        /// <param name="value">The value to be combined with the value at <paramref name="location1"/>.</param>
+        /// <returns>The original value in <paramref name="location1"/>.</returns>
+        /// <exception cref="NullReferenceException">The address of <paramref name="location1"/> is a null pointer.</exception>
+        /// <exception cref="NotSupportedException">An unsupported <typeparamref name="T"/> is specified.</exception>
+        /// <typeparam name="T">
+        /// The type to be used for <paramref name="location1"/> and <paramref name="value"/>.
+        /// This type must be an integer primitive type or an enum type backed by an integer type.
+        /// Floating-point types (float, double) are not supported.
+        /// </typeparam>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe T And<T>(ref T location1, T value) where T : struct
+        {
+            // Only integer primitive types and enum types backed by integer types are supported.
+            // Floating-point types and floating-point backed enums are not supported.
+            if ((!typeof(T).IsPrimitive && !typeof(T).IsEnum) ||
+                typeof(T) == typeof(float) || typeof(T) == typeof(double) ||
+                (typeof(T).IsEnum && (typeof(T).GetEnumUnderlyingType() == typeof(float) || typeof(T).GetEnumUnderlyingType() == typeof(double))))
+            {
+                throw new NotSupportedException(SR.NotSupported_IntegerEnumOrPrimitiveTypeRequired);
+            }
+
+            // For 1-byte and 2-byte types, we need to use CompareExchange-based implementations
+            // because there are no direct atomic And operations for these sizes.
+            if (sizeof(T) == 1)
+            {
+                byte current = Unsafe.BitCast<T, byte>(location1);
+                while (true)
+                {
+                    byte newValue = (byte)(current & Unsafe.BitCast<T, byte>(value));
+                    byte oldValue = CompareExchange(
+                        ref Unsafe.As<T, byte>(ref location1),
+                        newValue,
+                        current);
+                    if (oldValue == current)
+                    {
+                        return Unsafe.BitCast<byte, T>(oldValue);
+                    }
+                    current = oldValue;
+                }
+            }
+
+            if (sizeof(T) == 2)
+            {
+                ushort current = Unsafe.BitCast<T, ushort>(location1);
+                while (true)
+                {
+                    ushort newValue = (ushort)(current & Unsafe.BitCast<T, ushort>(value));
+                    ushort oldValue = CompareExchange(
+                        ref Unsafe.As<T, ushort>(ref location1),
+                        newValue,
+                        current);
+                    if (oldValue == current)
+                    {
+                        return Unsafe.BitCast<ushort, T>(oldValue);
+                    }
+                    current = oldValue;
+                }
+            }
+
+            if (sizeof(T) == 4)
+            {
+                return Unsafe.BitCast<int, T>(
+                    And(
+                        ref Unsafe.As<T, int>(ref location1),
+                        Unsafe.BitCast<T, int>(value)));
+            }
+
+            Debug.Assert(sizeof(T) == 8);
+            return Unsafe.BitCast<long, T>(
+                And(
+                    ref Unsafe.As<T, long>(ref location1),
+                    Unsafe.BitCast<T, long>(value)));
+        }
         #endregion
 
         #region Or
@@ -700,6 +777,83 @@ public static long Or(ref long location1, long value)
         [CLSCompliant(false)]
         public static ulong Or(ref ulong location1, ulong value) =>
             (ulong)Or(ref Unsafe.As<ulong, long>(ref location1), (long)value);
+
+        /// <summary>Bitwise "ors" two values of type <typeparamref name="T"/> and replaces the first value with the result, as an atomic operation.</summary>
+        /// <param name="location1">A variable containing the first value to be combined. The result is stored in <paramref name="location1"/>.</param>
+        /// <param name="value">The value to be combined with the value at <paramref name="location1"/>.</param>
+        /// <returns>The original value in <paramref name="location1"/>.</returns>
+        /// <exception cref="NullReferenceException">The address of <paramref name="location1"/> is a null pointer.</exception>
+        /// <exception cref="NotSupportedException">An unsupported <typeparamref name="T"/> is specified.</exception>
+        /// <typeparam name="T">
+        /// The type to be used for <paramref name="location1"/> and <paramref name="value"/>.
+        /// This type must be an integer primitive type or an enum type backed by an integer type.
+        /// Floating-point types (float, double) are not supported.
+        /// </typeparam>
+        [Intrinsic]
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static unsafe T Or<T>(ref T location1, T value) where T : struct
+        {
+            // Only integer primitive types and enum types backed by integer types are supported.
+            // Floating-point types and floating-point backed enums are not supported.
+            if ((!typeof(T).IsPrimitive && !typeof(T).IsEnum) ||
+                typeof(T) == typeof(float) || typeof(T) == typeof(double) ||
+                (typeof(T).IsEnum && (typeof(T).GetEnumUnderlyingType() == typeof(float) || typeof(T).GetEnumUnderlyingType() == typeof(double))))
+            {
+                throw new NotSupportedException(SR.NotSupported_IntegerEnumOrPrimitiveTypeRequired);
+            }
+
+            // For 1-byte and 2-byte types, we need to use CompareExchange-based implementations
+            // because there are no direct atomic Or operations for these sizes.
+            if (sizeof(T) == 1)
+            {
+                byte current = Unsafe.BitCast<T, byte>(location1);
+                while (true)
+                {
+                    byte newValue = (byte)(current | Unsafe.BitCast<T, byte>(value));
+                    byte oldValue = CompareExchange(
+                        ref Unsafe.As<T, byte>(ref location1),
+                        newValue,
+                        current);
+                    if (oldValue == current)
+                    {
+                        return Unsafe.BitCast<byte, T>(oldValue);
+                    }
+                    current = oldValue;
+                }
+            }
+
+            if (sizeof(T) == 2)
+            {
+                ushort current = Unsafe.BitCast<T, ushort>(location1);
+                while (true)
+                {
+                    ushort newValue = (ushort)(current | Unsafe.BitCast<T, ushort>(value));
+                    ushort oldValue = CompareExchange(
+                        ref Unsafe.As<T, ushort>(ref location1),
+                        newValue,
+                        current);
+                    if (oldValue == current)
+                    {
+                        return Unsafe.BitCast<ushort, T>(oldValue);
+                    }
+                    current = oldValue;
+                }
+            }
+
+            if (sizeof(T) == 4)
+            {
+                return Unsafe.BitCast<int, T>(
+                    Or(
+                        ref Unsafe.As<T, int>(ref location1),
+                        Unsafe.BitCast<T, int>(value)));
+            }
+
+            Debug.Assert(sizeof(T) == 8);
+            return Unsafe.BitCast<long, T>(
+                Or(
+                    ref Unsafe.As<T, long>(ref location1),
+                    Unsafe.BitCast<T, long>(value)));
+        }
         #endregion
 
         #region MemoryBarrier

src/libraries/System.Private.Uri/src/System/Uri.cs

@@ -252,7 +252,7 @@ private void InterlockedSetFlags(Flags flags)
             {
                 // For built-in (simple) parsers, it is safe to do an Interlocked update here
                 Debug.Assert(sizeof(Flags) == sizeof(ulong));
-                Interlocked.Or(ref Unsafe.As<Flags, ulong>(ref _flags), (ulong)flags);
+                Interlocked.Or(ref _flags, flags);
             }
             else
             {

src/libraries/System.Private.Uri/src/System/UriScheme.cs

@@ -77,8 +77,8 @@ protected virtual void InitializeAndValidate(Uri uri, out UriFormatException? pa
             Debug.Assert(sizeof(Uri.Flags) == sizeof(ulong));
 
             // If ParseMinimal is called multiple times this Uri instance may be corrupted, throw an exception instead
-            ulong previous = Interlocked.Or(ref Unsafe.As<Uri.Flags, ulong>(ref uri._flags), (ulong)Uri.Flags.CustomParser_ParseMinimalAlreadyCalled);
-            if (((Uri.Flags)previous & Uri.Flags.CustomParser_ParseMinimalAlreadyCalled) != 0)
+            Uri.Flags previous = Interlocked.Or(ref uri._flags, Uri.Flags.CustomParser_ParseMinimalAlreadyCalled);
+            if ((previous & Uri.Flags.CustomParser_ParseMinimalAlreadyCalled) != 0)
             {
                 throw new InvalidOperationException(SR.net_uri_InitializeCalledAlreadyOrTooLate);
             }

src/libraries/System.Private.Uri/src/System/UriSyntax.cs

@@ -269,7 +269,7 @@ internal void InternalValidate(Uri thisUri, out UriFormatException? parsingError
 
             // InitializeAndValidate should not be called outside of the constructor
             Debug.Assert(sizeof(Uri.Flags) == sizeof(ulong));
-            Interlocked.Or(ref Unsafe.As<Uri.Flags, ulong>(ref thisUri._flags), (ulong)Uri.Flags.CustomParser_ParseMinimalAlreadyCalled);
+            Interlocked.Or(ref thisUri._flags, Uri.Flags.CustomParser_ParseMinimalAlreadyCalled);
         }
 
         internal string? InternalResolve(Uri thisBaseUri, Uri uriLink, out UriFormatException? parsingError)

src/libraries/System.Threading/ref/System.Threading.cs

@@ -255,6 +255,7 @@ public static partial class Interlocked
         public static uint And(ref uint location1, uint value) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static ulong And(ref ulong location1, ulong value) { throw null; }
+        public static T And<T>(ref T location1, T value) where T : struct { throw null; }
         public static double CompareExchange(ref double location1, double value, double comparand) { throw null; }
         public static byte CompareExchange(ref byte location1, byte value, byte comparand) { throw null; }
         [System.CLSCompliantAttribute(false)]
@@ -317,6 +318,7 @@ public static void MemoryBarrierProcessWide() { }
         public static uint Or(ref uint location1, uint value) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static ulong Or(ref ulong location1, ulong value) { throw null; }
+        public static T Or<T>(ref T location1, T value) where T : struct { throw null; }
         public static long Read(ref readonly long location) { throw null; }
         [System.CLSCompliantAttribute(false)]
         public static ulong Read(ref readonly ulong location) { throw null; }