src\libraries\Common\src\System\HexConverter.cs (10)
148vec = Vector128.CreateScalar(Unsafe.ReadUnaligned<ulong>(ref Unsafe.Add(ref srcRef, pos))).AsByte();
153vec = Vector128.CreateScalar(Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref srcRef, pos))).AsByte();
209EncodeTo_Vector128(source, Unsafe.BitCast<Span<char>, Span<ushort>>(destination), casing);
292return TryDecodeFrom_Vector128(Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<ushort>>(source), destination, out charsProcessed);
419Unsafe.WriteUnaligned(ref Unsafe.Add(ref destRef, offset / 2), output.AsUInt64().ToScalar());
441fallbackResult = TryDecodeFromUtf8_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed);
446fallbackResult = TryDecodeFromUtf16_Scalar(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(source.Slice((int)offset)), destination.Slice((int)(offset / 2)), out elementsProcessed);
src\libraries\System.Private.CoreLib\src\System\Array.cs (75)
380ref byte src = ref Unsafe.As<RawArrayData>(sourceArray).Data;
381ref byte dst = ref Unsafe.As<RawArrayData>(destinationArray).Data;
417ref byte src = ref Unsafe.AddByteOffset(ref Unsafe.As<RawArrayData>(sourceArray).Data, (uint)sourceIndex * elementSize);
418ref byte dst = ref Unsafe.AddByteOffset(ref Unsafe.As<RawArrayData>(destinationArray).Data, (uint)destinationIndex * elementSize);
468ref byte src = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(sourceArray), (uint)sourceIndex * elementSize);
469ref byte dst = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(destinationArray), (uint)destinationIndex * elementSize);
543ref object? srcData = ref Unsafe.Add(ref Unsafe.As<byte, object?>(ref MemoryMarshal.GetArrayDataReference(sourceArray)), sourceIndex);
544ref byte destData = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(destinationArray), (nuint)destinationIndex * destSize);
548object? obj = Unsafe.Add(ref srcData, i);
574destData = ref Unsafe.AddByteOffset(ref destData, destSize);
588ref byte srcData = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(sourceArray), (nuint)sourceIndex * srcSize);
589ref object? destData = ref Unsafe.Add(ref Unsafe.As<byte, object?>(ref MemoryMarshal.GetArrayDataReference(destinationArray)), destinationIndex);
598Unsafe.Add(ref destData, i) = obj;
599srcData = ref Unsafe.AddByteOffset(ref srcData, srcSize);
611ref object? srcData = ref Unsafe.Add(ref Unsafe.As<byte, object?>(ref MemoryMarshal.GetArrayDataReference(sourceArray)), sourceIndex);
612ref object? destData = ref Unsafe.Add(ref Unsafe.As<byte, object?>(ref MemoryMarshal.GetArrayDataReference(destinationArray)), destinationIndex);
616object? obj = Unsafe.Add(ref srcData, i);
624Unsafe.Add(ref destData, i) = CastHelpers.ChkCastAny(pDestMT, obj);
648ref byte srcData = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(sourceArray), (nuint)sourceIndex * srcElSize);
649ref byte destData = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destinationArray), (nuint)destinationIndex * destElSize);
654srcData = ref Unsafe.AddByteOffset(ref srcData, srcElSize);
655destData = ref Unsafe.AddByteOffset(ref destData, destElSize);
680SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, IntPtr>(ref pStart), totalByteLength / (nuint)sizeof(IntPtr));
694ref byte p = ref Unsafe.As<RawArrayData>(array).Data;
701lowerBound = Unsafe.Add(ref Unsafe.As<byte, int>(ref p), rank);
702p = ref Unsafe.Add(ref p, 2 * sizeof(int) * rank); // skip the bounds
712ref byte ptr = ref Unsafe.AddByteOffset(ref p, (uint)offset * elementSize);
716SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, IntPtr>(ref ptr), byteLength / (uint)sizeof(IntPtr));
731rawIndex -= Unsafe.Add(ref bounds, 1);
750int index = indices[i] - Unsafe.Add(ref bounds, indices.Length + i);
751int length = Unsafe.Add(ref bounds, i);
778return Unsafe.Add(ref this.GetMultiDimensionalArrayBounds(), dimension);
792return Unsafe.Add(ref bounds, dimension)
793+ (SupportsNonZeroLowerBound ? Unsafe.Add(ref bounds, rank + dimension) : 0)
808return Unsafe.Add(ref this.GetMultiDimensionalArrayBounds(), rank + dimension);
1344=> UnsafeArrayAsSpan<T>(array, adjustedIndex, length).BinarySearch(Unsafe.As<byte, T>(ref value.GetRawData()));
1517ref T first = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)startIndex);
1852=> UnsafeArrayAsSpan<T>(array, adjustedIndex, length).IndexOf(Unsafe.As<byte, T>(ref value.GetRawData()));
1919ref Unsafe.Add(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(array)), startIndex),
1920Unsafe.BitCast<T, byte>(value),
1927ref Unsafe.Add(ref Unsafe.As<T, short>(ref MemoryMarshal.GetArrayDataReference(array)), startIndex),
1928Unsafe.BitCast<T, short>(value),
1935ref Unsafe.Add(ref Unsafe.As<T, int>(ref MemoryMarshal.GetArrayDataReference(array)), startIndex),
1936Unsafe.BitCast<T, int>(value),
1943ref Unsafe.Add(ref Unsafe.As<T, long>(ref MemoryMarshal.GetArrayDataReference(array)), startIndex),
1944Unsafe.BitCast<T, long>(value),
2079=> UnsafeArrayAsSpan<T>(array, adjustedIndex, length).LastIndexOf(Unsafe.As<byte, T>(ref value.GetRawData()));
2164ref Unsafe.Add(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetArrayDataReference(array)), endIndex),
2165Unsafe.BitCast<T, byte>(value),
2174ref Unsafe.Add(ref Unsafe.As<T, short>(ref MemoryMarshal.GetArrayDataReference(array)), endIndex),
2175Unsafe.BitCast<T, short>(value),
2184ref Unsafe.Add(ref Unsafe.As<T, int>(ref MemoryMarshal.GetArrayDataReference(array)), endIndex),
2185Unsafe.BitCast<T, int>(value),
2194ref Unsafe.Add(ref Unsafe.As<T, long>(ref MemoryMarshal.GetArrayDataReference(array)), endIndex),
2195Unsafe.BitCast<T, long>(value),
2314SpanHelpers.Reverse(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index), (nuint)length);
2564var span = new Span<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index), length);
2588var spanKeys = new Span<TKey>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(keys), index), length);
2589var spanItems = new Span<TValue>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(items), index), length);
3073new Span<T>(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(array)), array.Length).Slice(adjustedIndex, length);
src\libraries\System.Private.CoreLib\src\System\BitConverter.cs (41)
47Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value ? (byte)1 : (byte)0);
75Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
103Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
131Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
159Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
187Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
217Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
247Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
277Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
307Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
335Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
363Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
391Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
419Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);
445return Unsafe.ReadUnaligned<char>(ref MemoryMarshal.GetReference(value));
466return Unsafe.ReadUnaligned<short>(ref value[startIndex]);
480return Unsafe.ReadUnaligned<short>(ref MemoryMarshal.GetReference(value));
504return Unsafe.ReadUnaligned<int>(ref value[startIndex]);
518return Unsafe.ReadUnaligned<int>(ref MemoryMarshal.GetReference(value));
542return Unsafe.ReadUnaligned<long>(ref value[startIndex]);
556return Unsafe.ReadUnaligned<long>(ref MemoryMarshal.GetReference(value));
580return Unsafe.ReadUnaligned<Int128>(ref value[startIndex]);
594return Unsafe.ReadUnaligned<Int128>(ref MemoryMarshal.GetReference(value));
621return Unsafe.ReadUnaligned<ushort>(ref MemoryMarshal.GetReference(value));
651return Unsafe.ReadUnaligned<uint>(ref MemoryMarshal.GetReference(value));
681return Unsafe.ReadUnaligned<ulong>(ref MemoryMarshal.GetReference(value));
706return Unsafe.ReadUnaligned<UInt128>(ref value[startIndex]);
721return Unsafe.ReadUnaligned<UInt128>(ref MemoryMarshal.GetReference(value));
746return Unsafe.ReadUnaligned<BFloat16>(ref MemoryMarshal.GetReference(value));
771return Unsafe.ReadUnaligned<Half>(ref MemoryMarshal.GetReference(value));
799return Unsafe.ReadUnaligned<float>(ref MemoryMarshal.GetReference(value));
827return Unsafe.ReadUnaligned<double>(ref MemoryMarshal.GetReference(value));
953return Unsafe.ReadUnaligned<byte>(ref MemoryMarshal.GetReference(value)) != 0;
962public static long DoubleToInt64Bits(double value) => Unsafe.BitCast<double, long>(value);
970public static double Int64BitsToDouble(long value) => Unsafe.BitCast<long, double>(value);
978public static int SingleToInt32Bits(float value) => Unsafe.BitCast<float, int>(value);
986public static float Int32BitsToSingle(int value) => Unsafe.BitCast<int, float>(value);
1027public static ulong DoubleToUInt64Bits(double value) => Unsafe.BitCast<double, ulong>(value);
1036public static double UInt64BitsToDouble(ulong value) => Unsafe.BitCast<ulong, double>(value);
1045public static uint SingleToUInt32Bits(float value) => Unsafe.BitCast<float, uint>(value);
1054public static float UInt32BitsToSingle(uint value) => Unsafe.BitCast<uint, float>(value);
src\libraries\System.Private.CoreLib\src\System\Buffer.cs (14)
53Memmove(ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(dst), uDstOffset), ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(src), uSrcOffset), uCount);
85return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index);
96Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index) = value;
137ref Unsafe.As<T, byte>(ref destination),
138ref Unsafe.As<T, byte>(ref source),
145ref Unsafe.As<T, byte>(ref destination),
146ref Unsafe.As<T, byte>(ref source),
177if (Unsafe.AreSame(ref source, ref destination))
181if ((nuint)(nint)Unsafe.ByteOffset(ref source, ref destination) >= byteCount)
189destination = ref Unsafe.AddByteOffset(ref destination, BulkMoveWithWriteBarrierChunk);
190source = ref Unsafe.AddByteOffset(ref source, BulkMoveWithWriteBarrierChunk);
200BulkMoveWithWriteBarrierInternal(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);
src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64DecoderHelper.cs (22)
175int i2 = Unsafe.Add(ref decodingMap, (IntPtr)t2);
176int i3 = Unsafe.Add(ref decodingMap, (IntPtr)t3);
198int i2 = Unsafe.Add(ref decodingMap, (IntPtr)t2);
396int i0 = Unsafe.Add(ref decodingMap, (int)t0);
397int i1 = Unsafe.Add(ref decodingMap, (int)t1);
406int i2 = Unsafe.Add(ref decodingMap, (int)t2);
407int i3 = Unsafe.Add(ref decodingMap, (int)t3);
424int i2 = Unsafe.Add(ref decodingMap, (int)t2);
681if (decoder.IsValidPadding(Unsafe.Subtract(ref ptrToLastElement, 1)))
700if (decoder.IsValidPadding(Unsafe.Subtract(ref ptrToLastElement, 1)))
1520int i0 = Unsafe.Add(ref decodingMap, (int)t0);
1521int i1 = Unsafe.Add(ref decodingMap, (int)t1);
1522int i2 = Unsafe.Add(ref decodingMap, (int)t2);
1523int i3 = Unsafe.Add(ref decodingMap, (int)t3);
1564int i0 = Unsafe.Add(ref decodingMap, (IntPtr)t0);
1565int i1 = Unsafe.Add(ref decodingMap, (IntPtr)t1);
1731int i0 = Unsafe.Add(ref decodingMap, (int)t0);
1732int i1 = Unsafe.Add(ref decodingMap, (int)t1);
1733int i2 = Unsafe.Add(ref decodingMap, (int)t2);
1734int i3 = Unsafe.Add(ref decodingMap, (int)t3);
1780int i0 = Unsafe.Add(ref decodingMap, (IntPtr)t0);
1781int i1 = Unsafe.Add(ref decodingMap, (IntPtr)t1);
src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64EncoderHelper.cs (24)
621Unsafe.WriteUnaligned(bufferBytes + destinationIndex, result);
640uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
641uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
642uint i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
643uint i3 = Unsafe.Add(ref encodingMap, (IntPtr)(i & 0x3F));
668uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 10));
669uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 4) & 0x3F));
682Unsafe.WriteUnaligned(dest, result);
693ushort i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
694ushort i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
695ushort i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
738uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 10));
739uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 4) & 0x3F));
742Unsafe.WriteUnaligned(dest, result);
753uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
754uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
755uint i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
758Unsafe.WriteUnaligned(dest, result);
798Unsafe.WriteUnaligned(destination, result);
892ulong i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
893ulong i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
894ulong i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
895ulong i3 = Unsafe.Add(ref encodingMap, (IntPtr)(i & 0x3F));
907Unsafe.WriteUnaligned(destination, result);
src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.cs (8)
58Unsafe.SkipInit(out value); // will be populated by TryParseByteX
59return TryParseByteX(source, out Unsafe.As<sbyte, byte>(ref value), out bytesConsumed);
110Unsafe.SkipInit(out value); // will be populated by TryParseUInt16X
111return TryParseUInt16X(source, out Unsafe.As<short, ushort>(ref value), out bytesConsumed);
162Unsafe.SkipInit(out value); // will be populated by TryParseUInt32X
163return TryParseUInt32X(source, out Unsafe.As<int, uint>(ref value), out bytesConsumed);
214Unsafe.SkipInit(out value); // will be populated by TryParseUInt64X
215return TryParseUInt64X(source, out Unsafe.As<long, ulong>(ref value), out bytesConsumed);
src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ArraySortHelper.cs (21)
401Debug.Assert(!Unsafe.AreSame(ref i, ref j));
464ref T lastRef = ref Unsafe.Add(ref zeroRef, keys.Length - 1);
465ref T middleRef = ref Unsafe.Add(ref zeroRef, (keys.Length - 1) >> 1);
471ref T nextToLastRef = ref Unsafe.Add(ref zeroRef, keys.Length - 2);
477while (Unsafe.IsAddressLessThan(ref leftRef, ref rightRef))
481while (Unsafe.IsAddressLessThan(ref leftRef, ref nextToLastRef) && (leftRef = ref Unsafe.Add(ref leftRef, 1)) == null) ;
482while (Unsafe.IsAddressGreaterThan(ref rightRef, ref zeroRef) && (rightRef = ref Unsafe.Add(ref rightRef, -1)) != null) ;
486while (Unsafe.IsAddressLessThan(ref leftRef, ref nextToLastRef) && GreaterThan(ref pivot, ref leftRef = ref Unsafe.Add(ref leftRef, 1))) ;
487while (Unsafe.IsAddressGreaterThan(ref rightRef, ref zeroRef) && LessThan(ref pivot, ref rightRef = ref Unsafe.Add(ref rightRef, -1))) ;
490if (Unsafe.IsAddressGreaterThanOrEqualTo(ref leftRef, ref rightRef))
499if (!Unsafe.AreSame(ref leftRef, ref nextToLastRef))
504return (int)((nint)Unsafe.ByteOffset(ref zeroRef, ref leftRef) / sizeof(T));
549T t = Unsafe.Add(ref MemoryMarshal.GetReference(keys), i + 1);
552while (j >= 0 && (t == null || LessThan(ref t, ref Unsafe.Add(ref MemoryMarshal.GetReference(keys), j))))
554Unsafe.Add(ref MemoryMarshal.GetReference(keys), j + 1) = Unsafe.Add(ref MemoryMarshal.GetReference(keys), j);
558Unsafe.Add(ref MemoryMarshal.GetReference(keys), j + 1) = t!;
src\libraries\System.Private.CoreLib\src\System\Enum.cs (111)
421ushort flagsValue = Unsafe.As<byte, ushort>(ref pFlagsValue);
422return (Unsafe.As<byte, ushort>(ref pThisValue) & flagsValue) == flagsValue;
428uint flagsValue = Unsafe.As<byte, uint>(ref pFlagsValue);
429return (Unsafe.As<byte, uint>(ref pThisValue) & flagsValue) == flagsValue;
435ulong flagsValue = Unsafe.As<byte, ulong>(ref pFlagsValue);
436return (Unsafe.As<byte, ulong>(ref pThisValue) & flagsValue) == flagsValue;
890Unsafe.SkipInit(out result);
894if (underlyingType == typeof(sbyte)) return TryParseByValueOrName<sbyte, byte>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, sbyte>(ref result));
895if (underlyingType == typeof(byte)) return TryParseByValueOrName<byte, byte>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, byte>(ref result));
896if (underlyingType == typeof(short)) return TryParseByValueOrName<short, ushort>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, short>(ref result));
897if (underlyingType == typeof(ushort)) return TryParseByValueOrName<ushort, ushort>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, ushort>(ref result));
898if (underlyingType == typeof(int)) return TryParseByValueOrName<int, uint>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, int>(ref result));
899if (underlyingType == typeof(uint)) return TryParseByValueOrName<uint, uint>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, uint>(ref result));
900if (underlyingType == typeof(long)) return TryParseByValueOrName<long, ulong>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, long>(ref result));
901if (underlyingType == typeof(ulong)) return TryParseByValueOrName<ulong, ulong>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, ulong>(ref result));
903if (underlyingType == typeof(nint)) return TryParseRareTypeByValueOrName<nint, nuint>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, nint>(ref result));
904if (underlyingType == typeof(nuint)) return TryParseRareTypeByValueOrName<nuint, nuint>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, nuint>(ref result));
905if (underlyingType == typeof(float)) return TryParseRareTypeByValueOrName<float, float>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, float>(ref result));
906if (underlyingType == typeof(double)) return TryParseRareTypeByValueOrName<double, double>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, double>(ref result));
907if (underlyingType == typeof(char)) return TryParseRareTypeByValueOrName<char, char>(rt, value, ignoreCase, throwOnFailure, out Unsafe.As<TEnum, char>(ref result));
937Unsafe.SkipInit(out result);
938return TryParseByName(enumType, value, ignoreCase, throwOnFailure, out Unsafe.As<TUnderlying, TStorage>(ref result));
952Unsafe.SkipInit(out result);
953return TryParseByName(enumType, value, ignoreCase, throwOnFailure, out Unsafe.As<TUnderlying, TStorage>(ref result));
995Unsafe.SkipInit(out result);
996return TryParseByName(enumType, value, ignoreCase, throwOnFailure, out Unsafe.As<TUnderlying, TStorage>(ref result));
1019Unsafe.SkipInit(out result);
1020return TryParseByName(enumType, value, ignoreCase, throwOnFailure, out Unsafe.As<TUnderlying, TStorage>(ref result));
1169CorElementType.ELEMENT_TYPE_I1 => Unsafe.As<byte, sbyte>(ref data),
1171CorElementType.ELEMENT_TYPE_I2 => Unsafe.As<byte, short>(ref data),
1172CorElementType.ELEMENT_TYPE_U2 => Unsafe.As<byte, ushort>(ref data),
1173CorElementType.ELEMENT_TYPE_I4 => Unsafe.As<byte, int>(ref data),
1174CorElementType.ELEMENT_TYPE_U4 => Unsafe.As<byte, uint>(ref data),
1175CorElementType.ELEMENT_TYPE_I8 => Unsafe.As<byte, long>(ref data),
1176CorElementType.ELEMENT_TYPE_U8 => Unsafe.As<byte, ulong>(ref data),
1178CorElementType.ELEMENT_TYPE_R4 => Unsafe.As<byte, float>(ref data),
1179CorElementType.ELEMENT_TYPE_R8 => Unsafe.As<byte, double>(ref data),
1180CorElementType.ELEMENT_TYPE_I => Unsafe.As<byte, IntPtr>(ref data),
1181CorElementType.ELEMENT_TYPE_U => Unsafe.As<byte, UIntPtr>(ref data),
1182CorElementType.ELEMENT_TYPE_CHAR => Unsafe.As<byte, char>(ref data),
1183CorElementType.ELEMENT_TYPE_BOOLEAN => Unsafe.As<byte, bool>(ref data),
1213return Unsafe.As<byte, ushort>(ref pThisValue) == Unsafe.As<byte, ushort>(ref pOtherValue);
1217return Unsafe.As<byte, uint>(ref pThisValue) == Unsafe.As<byte, uint>(ref pOtherValue);
1221return Unsafe.As<byte, ulong>(ref pThisValue) == Unsafe.As<byte, ulong>(ref pOtherValue);
1260CorElementType.ELEMENT_TYPE_I1 => Unsafe.As<byte, sbyte>(ref data).GetHashCode(),
1262CorElementType.ELEMENT_TYPE_I2 => Unsafe.As<byte, short>(ref data).GetHashCode(),
1263CorElementType.ELEMENT_TYPE_U2 => Unsafe.As<byte, ushort>(ref data).GetHashCode(),
1264CorElementType.ELEMENT_TYPE_I4 => Unsafe.As<byte, int>(ref data).GetHashCode(),
1265CorElementType.ELEMENT_TYPE_U4 => Unsafe.As<byte, uint>(ref data).GetHashCode(),
1266CorElementType.ELEMENT_TYPE_I8 => Unsafe.As<byte, long>(ref data).GetHashCode(),
1267CorElementType.ELEMENT_TYPE_U8 => Unsafe.As<byte, ulong>(ref data).GetHashCode(),
1269CorElementType.ELEMENT_TYPE_R4 => Unsafe.As<byte, float>(ref data).GetHashCode(),
1270CorElementType.ELEMENT_TYPE_R8 => Unsafe.As<byte, double>(ref data).GetHashCode(),
1271CorElementType.ELEMENT_TYPE_I => Unsafe.As<byte, IntPtr>(ref data).GetHashCode(),
1272CorElementType.ELEMENT_TYPE_U => Unsafe.As<byte, UIntPtr>(ref data).GetHashCode(),
1273CorElementType.ELEMENT_TYPE_CHAR => Unsafe.As<byte, char>(ref data).GetHashCode(),
1274CorElementType.ELEMENT_TYPE_BOOLEAN => Unsafe.As<byte, bool>(ref data).GetHashCode(),
1298return Unsafe.As<byte, sbyte>(ref pThisValue).CompareTo(Unsafe.As<byte, sbyte>(ref pTargetValue));
1304return Unsafe.As<byte, short>(ref pThisValue).CompareTo(Unsafe.As<byte, short>(ref pTargetValue));
1307return Unsafe.As<byte, ushort>(ref pThisValue).CompareTo(Unsafe.As<byte, ushort>(ref pTargetValue));
1310return Unsafe.As<byte, int>(ref pThisValue).CompareTo(Unsafe.As<byte, int>(ref pTargetValue));
1313return Unsafe.As<byte, uint>(ref pThisValue).CompareTo(Unsafe.As<byte, uint>(ref pTargetValue));
1316return Unsafe.As<byte, long>(ref pThisValue).CompareTo(Unsafe.As<byte, long>(ref pTargetValue));
1319return Unsafe.As<byte, ulong>(ref pThisValue).CompareTo(Unsafe.As<byte, ulong>(ref pTargetValue));
1323return Unsafe.As<byte, float>(ref pThisValue).CompareTo(Unsafe.As<byte, float>(ref pTargetValue));
1326return Unsafe.As<byte, double>(ref pThisValue).CompareTo(Unsafe.As<byte, double>(ref pTargetValue));
1470TStorage value = Unsafe.As<byte, TStorage>(ref rawData);
1477return result ?? Unsafe.BitCast<TStorage, TUnderlying>(value).ToString()!;
1500TStorage value = Unsafe.As<byte, TStorage>(ref rawData);
1515result = Unsafe.BitCast<TStorage, TUnderlying>(value).ToString()!;
1567ushort value = Unsafe.As<byte, ushort>(ref data);
1578uint value = Unsafe.As<byte, uint>(ref data);
1591ulong value = Unsafe.As<byte, ulong>(ref data);
1700CorElementType.ELEMENT_TYPE_I2 => TryFormatPrimitiveDefault<short, ushort>(enumType, Unsafe.As<byte, short>(ref rawData), destination, out charsWritten),
1701CorElementType.ELEMENT_TYPE_U2 => TryFormatPrimitiveDefault<ushort, ushort>(enumType, Unsafe.As<byte, ushort>(ref rawData), destination, out charsWritten),
1702CorElementType.ELEMENT_TYPE_I4 => TryFormatPrimitiveDefault<int, uint>(enumType, Unsafe.As<byte, int>(ref rawData), destination, out charsWritten),
1703CorElementType.ELEMENT_TYPE_U4 => TryFormatPrimitiveDefault<uint, uint>(enumType, Unsafe.As<byte, uint>(ref rawData), destination, out charsWritten),
1704CorElementType.ELEMENT_TYPE_I8 => TryFormatPrimitiveDefault<long, ulong>(enumType, Unsafe.As<byte, long>(ref rawData), destination, out charsWritten),
1705CorElementType.ELEMENT_TYPE_U8 => TryFormatPrimitiveDefault<ulong, ulong>(enumType, Unsafe.As<byte, ulong>(ref rawData), destination, out charsWritten),
1707CorElementType.ELEMENT_TYPE_R4 => TryFormatPrimitiveDefault<float, float>(enumType, Unsafe.As<byte, float>(ref rawData), destination, out charsWritten),
1708CorElementType.ELEMENT_TYPE_R8 => TryFormatPrimitiveDefault<double, double>(enumType, Unsafe.As<byte, double>(ref rawData), destination, out charsWritten),
1709CorElementType.ELEMENT_TYPE_I => TryFormatPrimitiveDefault<nint, nuint>(enumType, Unsafe.As<byte, nint>(ref rawData), destination, out charsWritten),
1710CorElementType.ELEMENT_TYPE_U => TryFormatPrimitiveDefault<nuint, nuint>(enumType, Unsafe.As<byte, nuint>(ref rawData), destination, out charsWritten),
1711CorElementType.ELEMENT_TYPE_CHAR => TryFormatPrimitiveDefault<char, char>(enumType, Unsafe.As<byte, char>(ref rawData), destination, out charsWritten),
1722CorElementType.ELEMENT_TYPE_I2 => TryFormatPrimitiveNonDefault<short, ushort>(enumType, Unsafe.As<byte, short>(ref rawData), destination, out charsWritten, format),
1723CorElementType.ELEMENT_TYPE_U2 => TryFormatPrimitiveNonDefault<ushort, ushort>(enumType, Unsafe.As<byte, ushort>(ref rawData), destination, out charsWritten, format),
1724CorElementType.ELEMENT_TYPE_I4 => TryFormatPrimitiveNonDefault<int, uint>(enumType, Unsafe.As<byte, int>(ref rawData), destination, out charsWritten, format),
1725CorElementType.ELEMENT_TYPE_U4 => TryFormatPrimitiveNonDefault<uint, uint>(enumType, Unsafe.As<byte, uint>(ref rawData), destination, out charsWritten, format),
1726CorElementType.ELEMENT_TYPE_I8 => TryFormatPrimitiveNonDefault<long, ulong>(enumType, Unsafe.As<byte, long>(ref rawData), destination, out charsWritten, format),
1727CorElementType.ELEMENT_TYPE_U8 => TryFormatPrimitiveNonDefault<ulong, ulong>(enumType, Unsafe.As<byte, ulong>(ref rawData), destination, out charsWritten, format),
1729CorElementType.ELEMENT_TYPE_R4 => TryFormatPrimitiveNonDefault<float, float>(enumType, Unsafe.As<byte, float>(ref rawData), destination, out charsWritten, format),
1730CorElementType.ELEMENT_TYPE_R8 => TryFormatPrimitiveNonDefault<double, double>(enumType, Unsafe.As<byte, double>(ref rawData), destination, out charsWritten, format),
1731CorElementType.ELEMENT_TYPE_I => TryFormatPrimitiveNonDefault<nint, nuint>(enumType, Unsafe.As<byte, nint>(ref rawData), destination, out charsWritten, format),
1732CorElementType.ELEMENT_TYPE_U => TryFormatPrimitiveNonDefault<nuint, nuint>(enumType, Unsafe.As<byte, nuint>(ref rawData), destination, out charsWritten, format),
1733CorElementType.ELEMENT_TYPE_CHAR => TryFormatPrimitiveNonDefault<char, char>(enumType, Unsafe.As<byte, char>(ref rawData), destination, out charsWritten, format),
1867if (GetNameInlined(enumInfo, Unsafe.BitCast<TUnderlying, TStorage>(value)) is string enumName)
1882if (TryFormatFlagNames(enumInfo, Unsafe.BitCast<TUnderlying, TStorage>(value), destination, out charsWritten, ref destinationIsTooSmall) || destinationIsTooSmall)
1911return TryFormatNumberAsHex<TStorage>(ref Unsafe.As<TUnderlying, byte>(ref value), destination, out charsWritten);
1915if (TryFormatFlagNames(GetEnumInfo<TStorage>(enumType), Unsafe.BitCast<TUnderlying, TStorage>(value), destination, out charsWritten, ref destinationIsTooSmall) ||
src\libraries\System.Private.CoreLib\src\System\Globalization\CharUnicodeInfo.cs (27)
88StrongBidiCategory bidiCategory = (StrongBidiCategory)(Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoriesValues), offset) & 0b_0110_0000);
151uint rawValue = Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(DigitValues), offset);
185int rawValue = Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(DigitValues), offset);
199return (GraphemeClusterBreakType)Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(GraphemeSegmentationValues), offset);
217return (sbyte)Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoriesValues), offset) < 0;
263ref byte refToValue = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(NumericValues), offset * 8 /* sizeof(double) */);
269return Unsafe.ReadUnaligned<double>(ref refToValue);
273ulong temp = Unsafe.ReadUnaligned<ulong>(ref refToValue);
287ref short rsStart = ref Unsafe.As<byte, short>(ref MemoryMarshal.GetReference(UppercaseValues));
288ref short rsDelta = ref Unsafe.Add(ref rsStart, (nint)offset);
306ref ushort rsStart = ref Unsafe.As<byte, ushort>(ref MemoryMarshal.GetReference(UppercaseValues));
307ref ushort rsDelta = ref Unsafe.Add(ref rsStart, (nint)offset);
322ref short rsStart = ref Unsafe.As<byte, short>(ref MemoryMarshal.GetReference(LowercaseValues));
323ref short rsDelta = ref Unsafe.Add(ref rsStart, (nint)offset);
341ref ushort rsStart = ref Unsafe.As<byte, ushort>(ref MemoryMarshal.GetReference(LowercaseValues));
342ref ushort rsDelta = ref Unsafe.Add(ref rsStart, (nint)offset);
421return (UnicodeCategory)(Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoriesValues), offset) & 0x1F);
482uint index = Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoryCasingLevel1Index), codePoint >> 9);
488ref byte level2Ref = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoryCasingLevel2Index), (index << 6) + ((codePoint >> 3) & 0b_0011_1110));
492index = Unsafe.ReadUnaligned<ushort>(ref level2Ref);
496index = BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ushort>(ref level2Ref));
502return Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(CategoryCasingLevel3Index), (index << 4) + (codePoint & 0x0F));
519uint index = Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(NumericGraphemeLevel1Index), codePoint >> 9);
525ref byte level2Ref = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(NumericGraphemeLevel2Index), (index << 6) + ((codePoint >> 3) & 0b_0011_1110));
529index = Unsafe.ReadUnaligned<ushort>(ref level2Ref);
533index = BinaryPrimitives.ReverseEndianness(Unsafe.ReadUnaligned<ushort>(ref level2Ref));
539return Unsafe.AddByteOffset(ref MemoryMarshal.GetReference(NumericGraphemeLevel3Index), (index << 4) + (codePoint & 0x0F));
src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormat.cs (5)
766result.Append(Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(s));
771Encoding.UTF8.GetBytes(s, Unsafe.BitCast<Span<TChar>, Span<byte>>(result.AppendSpan(Encoding.UTF8.GetByteCount(s))));
780fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture) :
781fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture);
1115bool success = Unsafe.AreSame(ref MemoryMarshal.GetReference(destination), ref MemoryMarshal.GetReference(vlb.AsSpan()));
src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormatInfo.cs (10)
366Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(AMDesignator) :
367Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(amDesignatorUtf8 ??= Encoding.UTF8.GetBytes(AMDesignator));
615Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DateSeparator) :
616Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(dateSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DateSeparator));
818Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(PMDesignator) :
819Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(pmDesignatorUtf8 ??= Encoding.UTF8.GetBytes(PMDesignator));
1000Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(TimeSeparator) :
1001Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(timeSeparatorUtf8 ??= Encoding.UTF8.GetBytes(TimeSeparator));
1700Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(DecimalSeparator) :
1701Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_decimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(DecimalSeparator));
src\libraries\System.Private.CoreLib\src\System\Globalization\NumberFormatInfo.cs (28)
271Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyDecimalSeparator) :
272Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyDecimalSeparator));
363Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencyGroupSeparator) :
364Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencyGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_currencyGroupSeparator));
385Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_currencySymbol) :
386Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_currencySymbolUtf8 ??= Encoding.UTF8.GetBytes(_currencySymbol));
431Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_nanSymbol) :
432Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_nanSymbolUtf8 ??= Encoding.UTF8.GetBytes(_nanSymbol));
516Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeInfinitySymbol) :
517Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_negativeInfinitySymbol));
539Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_negativeSign) :
540Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_negativeSignUtf8 ??= Encoding.UTF8.GetBytes(_negativeSign));
575Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberDecimalSeparator) :
576Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberDecimalSeparator));
596Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_numberGroupSeparator) :
597Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_numberGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_numberGroupSeparator));
633Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveInfinitySymbol) :
634Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveInfinitySymbolUtf8 ??= Encoding.UTF8.GetBytes(_positiveInfinitySymbol));
656Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_positiveSign) :
657Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_positiveSignUtf8 ??= Encoding.UTF8.GetBytes(_positiveSign));
692Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentDecimalSeparator) :
693Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentDecimalSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentDecimalSeparator));
713Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentGroupSeparator) :
714Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentGroupSeparatorUtf8 ??= Encoding.UTF8.GetBytes(_percentGroupSeparator));
734Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_percentSymbol) :
735Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_percentSymbolUtf8 ??= Encoding.UTF8.GetBytes(_percentSymbol));
756Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(_perMilleSymbol) :
757Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(_perMilleSymbolUtf8 ??= Encoding.UTF8.GetBytes(_perMilleSymbol));
src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.cs (33)
33charA = ref Unsafe.Add(ref charA, 1);
34charB = ref Unsafe.Add(ref charB, 1);
96vec1 = TVector.LoadUnsafe(ref Unsafe.As<char, ushort>(ref charA), i);
97vec2 = TVector.LoadUnsafe(ref Unsafe.As<char, ushort>(ref charB), i);
123vec1 = TVector.LoadUnsafe(ref Unsafe.As<char, ushort>(ref charA), i);
124vec2 = TVector.LoadUnsafe(ref Unsafe.As<char, ushort>(ref charB), i);
155ref Unsafe.Add(ref charA, i), (int)(lengthU - i),
156ref Unsafe.Add(ref charB, i), (int)(lengthU - i)) == 0;
187valueAu64 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charA, byteOffset)));
188valueBu64 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charB, byteOffset)));
222valueAu32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charA, byteOffset)));
223valueBu32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charB, byteOffset)));
250valueAu32 = Unsafe.AddByteOffset(ref charA, byteOffset);
251valueBu32 = Unsafe.AddByteOffset(ref charB, byteOffset);
294return CompareStringIgnoreCase(ref Unsafe.AddByteOffset(ref charA, byteOffset), length, ref Unsafe.AddByteOffset(ref charB, byteOffset), length) == 0;
377valueCharU = Unsafe.Add(ref valueRef, valueTailLength);
400? PackedSpanHelpers.IndexOfAnyIgnoreCase(ref Unsafe.Add(ref searchSpace, offset), valueCharL, searchSpaceMinusValueTailLength)
401: SpanHelpers.IndexOfAnyChar(ref Unsafe.Add(ref searchSpace, offset), valueCharU, valueCharL, searchSpaceMinusValueTailLength) :
402SpanHelpers.IndexOfChar(ref Unsafe.Add(ref searchSpace, offset), valueChar, searchSpaceMinusValueTailLength);
418ref Unsafe.Add(ref searchSpace, (nuint)(offset + 1)),
419ref Unsafe.Add(ref valueRef, 1), valueTailLength))
445char tmp = Unsafe.Add(ref valueRef, ch1ch2Distance - 1);
507if (EqualsIgnoreCase(ref Unsafe.Add(ref searchSpace, offset + charPos), ref valueRef, value.Length))
573if (EqualsIgnoreCase(ref Unsafe.Add(ref searchSpace, offset + charPos), ref valueRef, value.Length))
src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.Utf8.cs (56)
38charA = ref Unsafe.Add(ref charA, 1);
39charB = ref Unsafe.Add(ref charB, 1);
145return EqualsIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref charA, i), (int)(lengthU - i), ref Unsafe.Add(ref charB, i), (int)(lengthU - i));
156ref Unsafe.Add(ref charA, i), lengthA - (int)i,
157ref Unsafe.Add(ref charB, i), lengthB - (int)i
186valueAu64 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.AddByteOffset(ref charA, byteOffset));
187valueBu64 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.AddByteOffset(ref charB, byteOffset));
225valueAu32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.AddByteOffset(ref charA, byteOffset));
226valueBu32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.AddByteOffset(ref charB, byteOffset));
260valueAu32 = Unsafe.ReadUnaligned<ushort>(ref Unsafe.AddByteOffset(ref charA, byteOffset));
261valueBu32 = Unsafe.ReadUnaligned<ushort>(ref Unsafe.AddByteOffset(ref charB, byteOffset));
265valueAu32 |= (uint)(Unsafe.AddByteOffset(ref charA, byteOffset) << 16);
266valueBu32 |= (uint)(Unsafe.AddByteOffset(ref charB, byteOffset) << 16);
270valueAu32 = Unsafe.ReadUnaligned<ushort>(ref Unsafe.AddByteOffset(ref charA, byteOffset));
271valueBu32 = Unsafe.ReadUnaligned<ushort>(ref Unsafe.AddByteOffset(ref charB, byteOffset));
277valueAu32 = Unsafe.AddByteOffset(ref charA, byteOffset);
278valueBu32 = Unsafe.AddByteOffset(ref charB, byteOffset);
326return EqualsStringIgnoreCaseUtf8(ref Unsafe.AddByteOffset(ref charA, byteOffset), lengthA - range, ref Unsafe.AddByteOffset(ref charB, byteOffset), lengthB - range);
348source = ref Unsafe.Add(ref source, 1);
349prefix = ref Unsafe.Add(ref prefix, 1);
455return StartsWithIgnoreCaseUtf8_Scalar(ref Unsafe.Add(ref source, i), (int)(lengthU - i), ref Unsafe.Add(ref prefix, i), (int)(lengthU - i));
466ref Unsafe.Add(ref source, i), sourceLength - (int)i,
467ref Unsafe.Add(ref prefix, i), prefixLength - (int)i
496valueAu64 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.AddByteOffset(ref source, byteOffset));
497valueBu64 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.AddByteOffset(ref prefix, byteOffset));
535valueAu32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.AddByteOffset(ref source, byteOffset));
536valueBu32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.AddByteOffset(ref prefix, byteOffset));
570valueAu32 = Unsafe.ReadUnaligned<ushort>(ref Unsafe.AddByteOffset(ref source, byteOffset));
571valueBu32 = Unsafe.ReadUnaligned<ushort>(ref Unsafe.AddByteOffset(ref prefix, byteOffset));
575valueAu32 |= (uint)(Unsafe.AddByteOffset(ref source, byteOffset) << 16);
576valueBu32 |= (uint)(Unsafe.AddByteOffset(ref prefix, byteOffset) << 16);
580valueAu32 = Unsafe.ReadUnaligned<ushort>(ref Unsafe.AddByteOffset(ref source, byteOffset));
581valueBu32 = Unsafe.ReadUnaligned<ushort>(ref Unsafe.AddByteOffset(ref prefix, byteOffset));
587valueAu32 = Unsafe.AddByteOffset(ref source, byteOffset);
588valueBu32 = Unsafe.AddByteOffset(ref prefix, byteOffset);
640return StartsWithStringIgnoreCaseUtf8(ref Unsafe.AddByteOffset(ref source, byteOffset), sourceLength - range, ref Unsafe.AddByteOffset(ref prefix, byteOffset), prefixLength - range);
src\libraries\System.Private.CoreLib\src\System\Globalization\OrdinalCasing.Icu.cs (11)
193if (!char.IsHighSurrogate(a) || index >= lengthA - 1 || !char.IsLowSurrogate(lowSurrogateA = Unsafe.Add(ref charA, 1)))
195if (!char.IsHighSurrogate(b) || index >= lengthB - 1 || !char.IsLowSurrogate(Unsafe.Add(ref charB, 1)))
204charA = ref Unsafe.Add(ref charA, 1);
205charB = ref Unsafe.Add(ref charB, 1);
215charA = ref Unsafe.Add(ref charA, 1);
216charB = ref Unsafe.Add(ref charB, 1);
236if (!char.IsHighSurrogate(b) || index >= lengthB - 1 || !char.IsLowSurrogate(lowSurrogateB = Unsafe.Add(ref charB, 1)))
255charA = ref Unsafe.Add(ref charA, 2);
256charB = ref Unsafe.Add(ref charB, 2);
266charA = ref Unsafe.Add(ref charA, 2);
267charB = ref Unsafe.Add(ref charB, 2);
src\libraries\System.Private.CoreLib\src\System\Guid.cs (26)
248return Unsafe.As<GuidResult, Guid>(ref Unsafe.AsRef(in this));
324Unsafe.AsRef(in result._a) = (int)(unix_ts_ms >> 16);
325Unsafe.AsRef(in result._b) = (short)(unix_ts_ms);
327Unsafe.AsRef(in result._c) = (short)((result._c & ~VersionMask) | Version7Value);
328Unsafe.AsRef(in result._d) = (byte)((result._d & ~Variant10xxMask) | Variant10xxValue);
808Unsafe.Add(ref result._d, i) = (byte)byteVal;
901ReadOnlySpan<char> charSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(str);
930return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(new ReadOnlySpan<char>(chArr, 0, newLength));
936ReadOnlySpan<byte> srcUtf8Span = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(str);
989return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(destUtf8Span.Slice(0, newLength));
1078ref int r = ref Unsafe.AsRef(in _a);
1079return r ^ Unsafe.Add(ref r, 1) ^ Unsafe.Add(ref r, 2) ^ Unsafe.Add(ref r, 3);
1093return Unsafe.BitCast<Guid, Vector128<byte>>(left) == Unsafe.BitCast<Guid, Vector128<byte>>(right);
1096ref int rA = ref Unsafe.AsRef(in left._a);
1097ref int rB = ref Unsafe.AsRef(in right._a);
1102&& Unsafe.Add(ref rA, 1) == Unsafe.Add(ref rB, 1)
1103&& Unsafe.Add(ref rA, 2) == Unsafe.Add(ref rB, 2)
1104&& Unsafe.Add(ref rA, 3) == Unsafe.Add(ref rB, 3);
1529Vector128<byte> srcVec = Unsafe.BitCast<Guid, Vector128<byte>>(value);
src\libraries\System.Private.CoreLib\src\System\HashCode.cs (27)
321ref byte end = ref Unsafe.Add(ref pos, value.Length);
340Debug.Assert(Unsafe.ByteOffset(ref pos, ref end) >= sizeof(int));
341Add(Unsafe.ReadUnaligned<int>(ref pos));
342pos = ref Unsafe.Add(ref pos, sizeof(int));
345Debug.Assert(Unsafe.ByteOffset(ref pos, ref end) >= sizeof(int));
346Add(Unsafe.ReadUnaligned<int>(ref pos));
347pos = ref Unsafe.Add(ref pos, sizeof(int));
350Debug.Assert(Unsafe.ByteOffset(ref pos, ref end) >= sizeof(int));
351Add(Unsafe.ReadUnaligned<int>(ref pos));
352pos = ref Unsafe.Add(ref pos, sizeof(int));
359ref byte blockEnd = ref Unsafe.Subtract(ref end, Unsafe.ByteOffset(ref pos, ref end) % (sizeof(int) * 4));
360while (Unsafe.IsAddressLessThan(ref pos, ref blockEnd))
362Debug.Assert(Unsafe.ByteOffset(ref pos, ref blockEnd) >= (sizeof(int) * 4));
363uint v1 = Unsafe.ReadUnaligned<uint>(ref pos);
365uint v2 = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref pos, sizeof(int) * 1));
367uint v3 = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref pos, sizeof(int) * 2));
369uint v4 = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref pos, sizeof(int) * 3));
373pos = ref Unsafe.Add(ref pos, sizeof(int) * 4);
378while (Unsafe.ByteOffset(ref pos, ref end) >= sizeof(int))
380Add(Unsafe.ReadUnaligned<int>(ref pos));
381pos = ref Unsafe.Add(ref pos, sizeof(int));
385while (Unsafe.IsAddressLessThan(ref pos, ref end))
388pos = ref Unsafe.Add(ref pos, 1);
src\libraries\System.Private.CoreLib\src\System\IntPtr.cs (23)
245Unsafe.SkipInit(out result);
246return nint_t.TryParse(s, out Unsafe.As<nint, nint_t>(ref result));
252Unsafe.SkipInit(out result);
253return nint_t.TryParse(s, provider, out Unsafe.As<nint, nint_t>(ref result));
258Unsafe.SkipInit(out result);
259return nint_t.TryParse(s, style, provider, out Unsafe.As<nint, nint_t>(ref result));
264Unsafe.SkipInit(out result);
265return nint_t.TryParse(s, out Unsafe.As<nint, nint_t>(ref result));
274Unsafe.SkipInit(out result);
275return nint_t.TryParse(utf8Text, out Unsafe.As<nint, nint_t>(ref result));
285Unsafe.SkipInit(out result);
286return nint_t.TryParse(s, provider, out Unsafe.As<nint, nint_t>(ref result));
291Unsafe.SkipInit(out result);
292return nint_t.TryParse(s, style, provider, out Unsafe.As<nint, nint_t>(ref result));
388sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(nint_t));
391result = Unsafe.ReadUnaligned<nint>(ref sourceRef);
407result |= Unsafe.Add(ref sourceRef, i);
471result = Unsafe.ReadUnaligned<nint>(ref sourceRef);
489result |= Unsafe.Add(ref sourceRef, i);
1436Unsafe.SkipInit(out result);
1437return nint_t.TryParse(utf8Text, style, provider, out Unsafe.As<nint, nint_t>(ref result));
1446Unsafe.SkipInit(out result);
1447return nint_t.TryParse(utf8Text, provider, out Unsafe.As<nint, nint_t>(ref result));
src\libraries\System.Private.CoreLib\src\System\Marvin.OrdinalIgnoreCase.cs (6)
28tempValue = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref data, byteOffset)));
45tempValue = Unsafe.AddByteOffset(ref data, byteOffset);
78return ComputeHash32OrdinalIgnoreCaseSlow(ref Unsafe.AddByteOffset(ref data, byteOffset), (int)ucount, p0, p1);
93int hash = ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(scratch)), (uint)charsWritten * 2, p0, p1);
src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (450)
39return new Span<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */), array.Length - start);
63return new Span<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)actualIndex /* force zero-extension */), array.Length - actualIndex);
87return new Span<T>(ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */), length);
126return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetRawStringData(), (nint)(uint)start /* force zero-extension */), text.Length - start);
152return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetRawStringData(), (nint)(uint)actualIndex /* force zero-extension */), text.Length - actualIndex);
178return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetRawStringData(), (nint)(uint)start /* force zero-extension */), length);
210return new ReadOnlySpan<char>(ref Unsafe.Add(ref text.GetRawStringData(), (nint)(uint)start /* force zero-extension */), length);
335ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
336Unsafe.BitCast<T, byte>(value),
342ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
343Unsafe.BitCast<T, short>(value),
349ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
350Unsafe.BitCast<T, int>(value),
356ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
357Unsafe.BitCast<T, long>(value),
818ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
819Unsafe.BitCast<T, byte>(value),
825ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
826Unsafe.BitCast<T, short>(value),
832ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
833Unsafe.BitCast<T, int>(value),
839ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
840Unsafe.BitCast<T, long>(value),
867ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
868Unsafe.BitCast<T, byte>(value),
874ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
875Unsafe.BitCast<T, short>(value),
881ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
882Unsafe.BitCast<T, int>(value),
888ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
889Unsafe.BitCast<T, long>(value),
945ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
946Unsafe.BitCast<T, byte>(value0),
947Unsafe.BitCast<T, byte>(value1),
953ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
954Unsafe.BitCast<T, short>(value0),
955Unsafe.BitCast<T, short>(value1),
983ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
984Unsafe.BitCast<T, byte>(value0),
985Unsafe.BitCast<T, byte>(value1),
991ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
992Unsafe.BitCast<T, short>(value0),
993Unsafe.BitCast<T, short>(value1),
1052ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1053Unsafe.BitCast<T, byte>(value0),
1054Unsafe.BitCast<T, byte>(value1),
1055Unsafe.BitCast<T, byte>(value2),
1061ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1062Unsafe.BitCast<T, short>(value0),
1063Unsafe.BitCast<T, short>(value1),
1064Unsafe.BitCast<T, short>(value2),
1093ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1094Unsafe.BitCast<T, byte>(value0),
1095Unsafe.BitCast<T, byte>(value1),
1096Unsafe.BitCast<T, byte>(value2),
1102ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1103Unsafe.BitCast<T, short>(value0),
1104Unsafe.BitCast<T, short>(value1),
1105Unsafe.BitCast<T, short>(value2),
1155ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1156Unsafe.BitCast<T, byte>(value0),
1157Unsafe.BitCast<T, byte>(value1),
1158Unsafe.BitCast<T, byte>(value2),
1159Unsafe.BitCast<T, byte>(value3),
1165ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1166Unsafe.BitCast<T, short>(value0),
1167Unsafe.BitCast<T, short>(value1),
1168Unsafe.BitCast<T, short>(value2),
1169Unsafe.BitCast<T, short>(value3),
1212ref byte valuesRef = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values));
1215ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1217Unsafe.Add(ref valuesRef, 1),
1218Unsafe.Add(ref valuesRef, 2),
1219Unsafe.Add(ref valuesRef, 3),
1220Unsafe.Add(ref valuesRef, 4),
1225ref short valuesRef = ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(values));
1228ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1230Unsafe.Add(ref valuesRef, 1),
1231Unsafe.Add(ref valuesRef, 2),
1232Unsafe.Add(ref valuesRef, 3),
1233Unsafe.Add(ref valuesRef, 4),
1241ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
1243ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(values)),
1396ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1397Unsafe.BitCast<T, byte>(value),
1403ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1404Unsafe.BitCast<T, short>(value),
1410ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
1411Unsafe.BitCast<T, int>(value),
1417ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
1418Unsafe.BitCast<T, long>(value),
1445ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1446Unsafe.BitCast<T, byte>(value),
1452ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1453Unsafe.BitCast<T, short>(value),
1459ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
1460Unsafe.BitCast<T, int>(value),
1466ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
1467Unsafe.BitCast<T, long>(value),
1523ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1524Unsafe.BitCast<T, byte>(value0),
1525Unsafe.BitCast<T, byte>(value1),
1531ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1532Unsafe.BitCast<T, short>(value0),
1533Unsafe.BitCast<T, short>(value1),
1561ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1562Unsafe.BitCast<T, byte>(value0),
1563Unsafe.BitCast<T, byte>(value1),
1569ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1570Unsafe.BitCast<T, short>(value0),
1571Unsafe.BitCast<T, short>(value1),
1630ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1631Unsafe.BitCast<T, byte>(value0),
1632Unsafe.BitCast<T, byte>(value1),
1633Unsafe.BitCast<T, byte>(value2),
1639ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1640Unsafe.BitCast<T, short>(value0),
1641Unsafe.BitCast<T, short>(value1),
1642Unsafe.BitCast<T, short>(value2),
1671ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1672Unsafe.BitCast<T, byte>(value0),
1673Unsafe.BitCast<T, byte>(value1),
1674Unsafe.BitCast<T, byte>(value2),
1680ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1681Unsafe.BitCast<T, short>(value0),
1682Unsafe.BitCast<T, short>(value1),
1683Unsafe.BitCast<T, short>(value2),
1734ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1735Unsafe.BitCast<T, byte>(value0),
1736Unsafe.BitCast<T, byte>(value1),
1737Unsafe.BitCast<T, byte>(value2),
1738Unsafe.BitCast<T, byte>(value3),
1744ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1745Unsafe.BitCast<T, short>(value0),
1746Unsafe.BitCast<T, short>(value1),
1747Unsafe.BitCast<T, short>(value2),
1748Unsafe.BitCast<T, short>(value3),
1792ref byte valuesRef = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values));
1795ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1797Unsafe.Add(ref valuesRef, 1),
1798Unsafe.Add(ref valuesRef, 2),
1799Unsafe.Add(ref valuesRef, 3),
1800Unsafe.Add(ref valuesRef, 4),
1805ref short valuesRef = ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(values));
1808ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
1810Unsafe.Add(ref valuesRef, 1),
1811Unsafe.Add(ref valuesRef, 2),
1812Unsafe.Add(ref valuesRef, 3),
1813Unsafe.Add(ref valuesRef, 4),
1821ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
1823ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(values)),
1930ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
1931Unsafe.BitCast<T, byte>(lowInclusive),
1932Unsafe.BitCast<T, byte>(highInclusive),
1939ref Unsafe.As<T, ushort>(ref MemoryMarshal.GetReference(span)),
1940Unsafe.BitCast<T, ushort>(lowInclusive),
1941Unsafe.BitCast<T, ushort>(highInclusive),
1948ref Unsafe.As<T, uint>(ref MemoryMarshal.GetReference(span)),
1949Unsafe.BitCast<T, uint>(lowInclusive),
1950Unsafe.BitCast<T, uint>(highInclusive),
1957ref Unsafe.As<T, ulong>(ref MemoryMarshal.GetReference(span)),
1958Unsafe.BitCast<T, ulong>(lowInclusive),
1959Unsafe.BitCast<T, ulong>(highInclusive),
2001ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2002Unsafe.BitCast<T, byte>(lowInclusive),
2003Unsafe.BitCast<T, byte>(highInclusive),
2010ref Unsafe.As<T, ushort>(ref MemoryMarshal.GetReference(span)),
2011Unsafe.BitCast<T, ushort>(lowInclusive),
2012Unsafe.BitCast<T, ushort>(highInclusive),
2019ref Unsafe.As<T, uint>(ref MemoryMarshal.GetReference(span)),
2020Unsafe.BitCast<T, uint>(lowInclusive),
2021Unsafe.BitCast<T, uint>(highInclusive),
2028ref Unsafe.As<T, ulong>(ref MemoryMarshal.GetReference(span)),
2029Unsafe.BitCast<T, ulong>(lowInclusive),
2030Unsafe.BitCast<T, ulong>(highInclusive),
2072ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2073Unsafe.BitCast<T, byte>(lowInclusive),
2074Unsafe.BitCast<T, byte>(highInclusive),
2081ref Unsafe.As<T, ushort>(ref MemoryMarshal.GetReference(span)),
2082Unsafe.BitCast<T, ushort>(lowInclusive),
2083Unsafe.BitCast<T, ushort>(highInclusive),
2090ref Unsafe.As<T, uint>(ref MemoryMarshal.GetReference(span)),
2091Unsafe.BitCast<T, uint>(lowInclusive),
2092Unsafe.BitCast<T, uint>(highInclusive),
2099ref Unsafe.As<T, ulong>(ref MemoryMarshal.GetReference(span)),
2100Unsafe.BitCast<T, ulong>(lowInclusive),
2101Unsafe.BitCast<T, ulong>(highInclusive),
2143ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2144Unsafe.BitCast<T, byte>(lowInclusive),
2145Unsafe.BitCast<T, byte>(highInclusive),
2152ref Unsafe.As<T, ushort>(ref MemoryMarshal.GetReference(span)),
2153Unsafe.BitCast<T, ushort>(lowInclusive),
2154Unsafe.BitCast<T, ushort>(highInclusive),
2161ref Unsafe.As<T, uint>(ref MemoryMarshal.GetReference(span)),
2162Unsafe.BitCast<T, uint>(lowInclusive),
2163Unsafe.BitCast<T, uint>(highInclusive),
2170ref Unsafe.As<T, ulong>(ref MemoryMarshal.GetReference(span)),
2171Unsafe.BitCast<T, ulong>(lowInclusive),
2172Unsafe.BitCast<T, ulong>(highInclusive),
2216ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2217Unsafe.BitCast<T, byte>(value),
2222ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
2223Unsafe.BitCast<T, short>(value),
2228ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
2229Unsafe.BitCast<T, int>(value),
2234ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
2235Unsafe.BitCast<T, long>(value),
2257ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2258Unsafe.BitCast<T, byte>(value),
2263ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
2264Unsafe.BitCast<T, short>(value),
2269ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
2270Unsafe.BitCast<T, int>(value),
2275ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
2276Unsafe.BitCast<T, long>(value),
2325ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2327ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
2332ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
2334ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)),
2354ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2356ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
2361ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
2363ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)),
2412ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2413Unsafe.BitCast<T, byte>(value),
2419ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
2420Unsafe.BitCast<T, short>(value),
2426ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
2427Unsafe.BitCast<T, int>(value),
2433ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
2434Unsafe.BitCast<T, long>(value),
2458ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2459Unsafe.BitCast<T, byte>(value),
2465ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
2466Unsafe.BitCast<T, short>(value),
2472ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
2473Unsafe.BitCast<T, int>(value),
2479ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
2480Unsafe.BitCast<T, long>(value),
2532ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2534ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
2540ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
2542ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)),
2564ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2566ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
2572ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
2574ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(value)),
2675ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2676Unsafe.BitCast<T, byte>(value0),
2677Unsafe.BitCast<T, byte>(value1),
2683ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
2684Unsafe.BitCast<T, short>(value0),
2685Unsafe.BitCast<T, short>(value1),
2710ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2711Unsafe.BitCast<T, byte>(value0),
2712Unsafe.BitCast<T, byte>(value1),
2718ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
2719Unsafe.BitCast<T, short>(value0),
2720Unsafe.BitCast<T, short>(value1),
2775ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2776Unsafe.BitCast<T, byte>(value0),
2777Unsafe.BitCast<T, byte>(value1),
2778Unsafe.BitCast<T, byte>(value2),
2784ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
2785Unsafe.BitCast<T, short>(value0),
2786Unsafe.BitCast<T, short>(value1),
2787Unsafe.BitCast<T, short>(value2),
2813ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
2814Unsafe.BitCast<T, byte>(value0),
2815Unsafe.BitCast<T, byte>(value1),
2816Unsafe.BitCast<T, byte>(value2),
2822ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
2823Unsafe.BitCast<T, short>(value0),
2824Unsafe.BitCast<T, short>(value1),
2825Unsafe.BitCast<T, short>(value2),
2879ref byte spanRef = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span));
2880ref byte valueRef = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values));
2893Unsafe.Add(ref valueRef, 1),
2900Unsafe.Add(ref valueRef, 1),
2901Unsafe.Add(ref valueRef, 2),
2908Unsafe.Add(ref valueRef, 1),
2909Unsafe.Add(ref valueRef, 2),
2910Unsafe.Add(ref valueRef, 3),
2917Unsafe.Add(ref valueRef, 1),
2918Unsafe.Add(ref valueRef, 2),
2919Unsafe.Add(ref valueRef, 3),
2920Unsafe.Add(ref valueRef, 4),
2927ref short spanRef = ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span));
2928ref short valueRef = ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(values));
2936Unsafe.Add(ref valueRef, 1),
2941Unsafe.Add(ref valueRef, 1),
2942Unsafe.Add(ref valueRef, 2),
2947Unsafe.Add(ref valueRef, 1),
2948Unsafe.Add(ref valueRef, 2),
2949Unsafe.Add(ref valueRef, 3),
2954Unsafe.Add(ref valueRef, 1),
2955Unsafe.Add(ref valueRef, 2),
2956Unsafe.Add(ref valueRef, 3),
2957Unsafe.Add(ref valueRef, 4),
2959_ => ProbabilisticMap.IndexOfAny(ref Unsafe.As<short, char>(ref spanRef), span.Length, ref Unsafe.As<short, char>(ref valueRef), values.Length),
3095ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
3096Unsafe.BitCast<T, byte>(value0),
3097Unsafe.BitCast<T, byte>(value1),
3103ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
3104Unsafe.BitCast<T, short>(value0),
3105Unsafe.BitCast<T, short>(value1),
3130ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
3131Unsafe.BitCast<T, byte>(value0),
3132Unsafe.BitCast<T, byte>(value1),
3138ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
3139Unsafe.BitCast<T, short>(value0),
3140Unsafe.BitCast<T, short>(value1),
3196ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
3197Unsafe.BitCast<T, byte>(value0),
3198Unsafe.BitCast<T, byte>(value1),
3199Unsafe.BitCast<T, byte>(value2),
3205ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
3206Unsafe.BitCast<T, short>(value0),
3207Unsafe.BitCast<T, short>(value1),
3208Unsafe.BitCast<T, short>(value2),
3234ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
3235Unsafe.BitCast<T, byte>(value0),
3236Unsafe.BitCast<T, byte>(value1),
3237Unsafe.BitCast<T, byte>(value2),
3243ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
3244Unsafe.BitCast<T, short>(value0),
3245Unsafe.BitCast<T, short>(value1),
3246Unsafe.BitCast<T, short>(value2),
3301ref byte spanRef = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span));
3302ref byte valueRef = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values));
3315Unsafe.Add(ref valueRef, 1),
3322Unsafe.Add(ref valueRef, 1),
3323Unsafe.Add(ref valueRef, 2),
3330Unsafe.Add(ref valueRef, 1),
3331Unsafe.Add(ref valueRef, 2),
3332Unsafe.Add(ref valueRef, 3),
3339Unsafe.Add(ref valueRef, 1),
3340Unsafe.Add(ref valueRef, 2),
3341Unsafe.Add(ref valueRef, 3),
3342Unsafe.Add(ref valueRef, 4),
3349ref short spanRef = ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span));
3350ref short valueRef = ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(values));
3358Unsafe.Add(ref valueRef, 1),
3363Unsafe.Add(ref valueRef, 1),
3364Unsafe.Add(ref valueRef, 2),
3369Unsafe.Add(ref valueRef, 1),
3370Unsafe.Add(ref valueRef, 2),
3371Unsafe.Add(ref valueRef, 3),
3376Unsafe.Add(ref valueRef, 1),
3377Unsafe.Add(ref valueRef, 2),
3378Unsafe.Add(ref valueRef, 3),
3379Unsafe.Add(ref valueRef, 4),
3381_ => ProbabilisticMap.LastIndexOfAny(ref Unsafe.As<short, char>(ref spanRef), span.Length, ref Unsafe.As<short, char>(ref valueRef), values.Length),
3456ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
3457ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)),
3498ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
3499ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)),
3540ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
3542ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)),
3547ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(span)),
3549ref Unsafe.As<T, char>(ref MemoryMarshal.GetReference(other)),
3596ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
3597ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
3639ref Unsafe.As<T, byte>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (nint)(uint)(spanLength - valueLength) /* force zero-extension */)),
3640ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(value)),
3646ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (nint)(uint)(spanLength - valueLength) /* force zero-extension */),
4129nint byteOffset = Unsafe.ByteOffset(
4148nint byteOffset = Unsafe.ByteOffset(
4479ref byte src = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span));
4483Unsafe.BitCast<T, byte>(oldValue),
4484Unsafe.BitCast<T, byte>(newValue),
4491ref ushort src = ref Unsafe.As<T, ushort>(ref MemoryMarshal.GetReference(span));
4495Unsafe.BitCast<T, ushort>(oldValue),
4496Unsafe.BitCast<T, ushort>(newValue),
4502ref int src = ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span));
4506Unsafe.BitCast<T, int>(oldValue),
4507Unsafe.BitCast<T, int>(newValue),
4513ref long src = ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span));
4517Unsafe.BitCast<T, long>(oldValue),
4518Unsafe.BitCast<T, long>(newValue),
4545ref byte src = ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span));
4549Unsafe.BitCast<T, byte>(oldValue),
4550Unsafe.BitCast<T, byte>(newValue),
4557ref ushort src = ref Unsafe.As<T, ushort>(ref MemoryMarshal.GetReference(span));
4561Unsafe.BitCast<T, ushort>(oldValue),
4562Unsafe.BitCast<T, ushort>(newValue),
4568ref int src = ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span));
4572Unsafe.BitCast<T, int>(oldValue),
4573Unsafe.BitCast<T, int>(newValue),
4579ref long src = ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span));
4583Unsafe.BitCast<T, long>(oldValue),
4584Unsafe.BitCast<T, long>(newValue),
4646nint byteOffset = Unsafe.ByteOffset(ref src, ref dst);
4659ref Unsafe.As<T, byte>(ref src),
4660ref Unsafe.As<T, byte>(ref dst),
4661Unsafe.BitCast<T, byte>(oldValue),
4662Unsafe.BitCast<T, byte>(newValue),
4670ref Unsafe.As<T, ushort>(ref src),
4671ref Unsafe.As<T, ushort>(ref dst),
4672Unsafe.BitCast<T, ushort>(oldValue),
4673Unsafe.BitCast<T, ushort>(newValue),
4680ref Unsafe.As<T, int>(ref src),
4681ref Unsafe.As<T, int>(ref dst),
4682Unsafe.BitCast<T, int>(oldValue),
4683Unsafe.BitCast<T, int>(newValue),
4690ref Unsafe.As<T, long>(ref src),
4691ref Unsafe.As<T, long>(ref dst),
4692Unsafe.BitCast<T, long>(oldValue),
4693Unsafe.BitCast<T, long>(newValue),
4730nint byteOffset = Unsafe.ByteOffset(ref src, ref dst);
4745ref Unsafe.As<T, byte>(ref src),
4746ref Unsafe.As<T, byte>(ref dst),
4747Unsafe.BitCast<T, byte>(oldValue),
4748Unsafe.BitCast<T, byte>(newValue),
4756ref Unsafe.As<T, ushort>(ref src),
4757ref Unsafe.As<T, ushort>(ref dst),
4758Unsafe.BitCast<T, ushort>(oldValue),
4759Unsafe.BitCast<T, ushort>(newValue),
4766ref Unsafe.As<T, int>(ref src),
4767ref Unsafe.As<T, int>(ref dst),
4768Unsafe.BitCast<T, int>(oldValue),
4769Unsafe.BitCast<T, int>(newValue),
4776ref Unsafe.As<T, long>(ref src),
4777ref Unsafe.As<T, long>(ref dst),
4778Unsafe.BitCast<T, long>(oldValue),
4779Unsafe.BitCast<T, long>(newValue),
4833if (!Unsafe.AreSame(ref source._reference, ref destination._reference) &&
4883if (!Unsafe.AreSame(ref source._reference, ref destination._reference) &&
4942ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
4943ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(other)),
5433ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
5434Unsafe.BitCast<T, byte>(value),
5440ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
5441Unsafe.BitCast<T, short>(value),
5447ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
5448Unsafe.BitCast<T, int>(value),
5454ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
5455Unsafe.BitCast<T, long>(value),
5482ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(span)),
5483Unsafe.BitCast<T, byte>(value),
5489ref Unsafe.As<T, short>(ref MemoryMarshal.GetReference(span)),
5490Unsafe.BitCast<T, short>(value),
5496ref Unsafe.As<T, int>(ref MemoryMarshal.GetReference(span)),
5497Unsafe.BitCast<T, int>(value),
5503ref Unsafe.As<T, long>(ref MemoryMarshal.GetReference(span)),
5504Unsafe.BitCast<T, long>(value),
5929_searchValues = Unsafe.As<SearchValues<T>>(string.SearchValuesStorage.WhiteSpaceChars);
src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (8)
666if (source.TryCopyTo(Unsafe.BitCast<Span<TChar>, Span<char>>(destination)))
677return Encoding.UTF8.TryGetBytes(source, Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten);
1622Unsafe.CopyBlockUnaligned(
1624ref Unsafe.Add(ref GetTwoDigitsBytesRef(typeof(TChar) == typeof(char)), (uint)sizeof(TChar) * 2 * value),
1642Unsafe.CopyBlockUnaligned(
1644ref Unsafe.Add(ref charsArray, (uint)sizeof(TChar) * 2 * value),
1647Unsafe.CopyBlockUnaligned(
1649ref Unsafe.Add(ref charsArray, (uint)sizeof(TChar) * 2 * remainder),
src\libraries\System.Private.CoreLib\src\System\Number.Parsing.cs (13)
932ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span);
933ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value);
940ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span);
941ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value);
952return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span).Trim());
958return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span).TrimUtf8());
968ReadOnlySpan<char> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(span);
969ReadOnlySpan<char> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(value);
976ReadOnlySpan<byte> typedSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(span);
977ReadOnlySpan<byte> typedValue = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value);
1090ReadOnlySpan<byte> bytes = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value);
src\libraries\System.Private.CoreLib\src\System\Numerics\Vector.cs (92)
122Unsafe.SkipInit(out Vector<T> result);
149Unsafe.SkipInit(out Vector<T> result);
230return Unsafe.BitCast<Vector<TFrom>, Vector<TTo>>(vector);
372Unsafe.SkipInit(out Vector<T> result);
392Unsafe.SkipInit(out Vector<double> result);
411Unsafe.SkipInit(out Vector<float> result);
518Unsafe.SkipInit(out Vector<int> result);
535Unsafe.SkipInit(out Vector<int> result);
552Unsafe.SkipInit(out Vector<long> result);
569Unsafe.SkipInit(out Vector<long> result);
586Unsafe.SkipInit(out Vector<float> result);
627Unsafe.SkipInit(out Vector<uint> result);
645Unsafe.SkipInit(out Vector<uint> result);
663Unsafe.SkipInit(out Vector<ulong> result);
681Unsafe.SkipInit(out Vector<ulong> result);
695Unsafe.SkipInit(out Vector<T> result);
753Unsafe.SkipInit(out Vector<T> result);
814Unsafe.SkipInit(out Vector<T> result);
837return Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
866Unsafe.SkipInit(out Vector<T> result);
884Unsafe.SkipInit(out Vector<T> result);
958Unsafe.SkipInit(out Vector<T> result);
1028Unsafe.SkipInit(out Vector<T> result);
1089Unsafe.SkipInit(out Vector<T> result);
1109Unsafe.SkipInit(out Vector<double> result);
1128Unsafe.SkipInit(out Vector<float> result);
1152Unsafe.SkipInit(out Vector<double> result);
1176Unsafe.SkipInit(out Vector<float> result);
1215Unsafe.SkipInit(out Vector<T> result);
1303Unsafe.SkipInit(out Vector<T> result);
1385Unsafe.SkipInit(out Vector<T> result);
1712Unsafe.SkipInit(out Vector<T> result);
1770Unsafe.SkipInit(out Vector<T> result);
1858Unsafe.SkipInit(out Vector<T> result);
1986ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
1987return Unsafe.ReadUnaligned<Vector<T>>(in address);
2002ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2003return Unsafe.ReadUnaligned<Vector<T>>(in address);
2009Unsafe.SkipInit(out Vector<T> result);
2051Unsafe.SkipInit(out Vector<T> result);
2101Unsafe.SkipInit(out Vector<T> result);
2124Unsafe.SkipInit(out Vector<T> result);
2147Unsafe.SkipInit(out Vector<T> result);
2170Unsafe.SkipInit(out Vector<T> result);
2193Unsafe.SkipInit(out Vector<T> result);
2216Unsafe.SkipInit(out Vector<T> result);
2239Unsafe.SkipInit(out Vector<T> result);
2262Unsafe.SkipInit(out Vector<T> result);
2285Unsafe.SkipInit(out Vector<T> result);
2308Unsafe.SkipInit(out Vector<T> result);
2348Unsafe.SkipInit(out Vector<T> result);
2364Unsafe.SkipInit(out Vector<double> result);
2380Unsafe.SkipInit(out Vector<float> result);
2397Unsafe.SkipInit(out Vector<TResult> result);
2466Unsafe.SkipInit(out Vector<TResult> result);
2570Unsafe.SkipInit(out Vector<T> result);
2628Unsafe.SkipInit(out Vector<T> result);
2881Unsafe.SkipInit(out Vector<T> result);
2923Unsafe.SkipInit(out Vector<T> sinResult);
2924Unsafe.SkipInit(out Vector<T> cosResult);
2972Unsafe.SkipInit(out Vector<T> result);
3032ref byte address = ref Unsafe.As<T, byte>(ref destination);
3033Unsafe.WriteUnaligned(ref address, source);
3048destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
3049Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
3067Unsafe.SkipInit(out Vector<T> result);
3127Unsafe.SkipInit(out Vector<T> result);
3278Unsafe.SkipInit(out Vector<ushort> lower);
3296Unsafe.SkipInit(out Vector<int> lower);
3314Unsafe.SkipInit(out Vector<long> lower);
3333Unsafe.SkipInit(out Vector<short> lower);
3351Unsafe.SkipInit(out Vector<double> lower);
3370Unsafe.SkipInit(out Vector<uint> lower);
3389Unsafe.SkipInit(out Vector<ulong> lower);
3408Unsafe.SkipInit(out Vector<ushort> upper);
3426Unsafe.SkipInit(out Vector<int> upper);
3444Unsafe.SkipInit(out Vector<long> upper);
3463Unsafe.SkipInit(out Vector<short> upper);
3481Unsafe.SkipInit(out Vector<double> upper);
3500Unsafe.SkipInit(out Vector<uint> upper);
3519Unsafe.SkipInit(out Vector<ulong> upper);
3563ref T address = ref Unsafe.As<Vector<T>, T>(ref Unsafe.AsRef(in vector));
3564return Unsafe.Add(ref address, index);
3571ref T address = ref Unsafe.As<Vector<T>, T>(ref Unsafe.AsRef(in vector));
3572Unsafe.Add(ref address, index) = value;
src\libraries\System.Private.CoreLib\src\System\Numerics\Vector_1.cs (30)
61this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref values[0]));
80this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref values[index]));
97this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
115this = Unsafe.ReadUnaligned<Vector<T>>(ref MemoryMarshal.GetReference(values));
156Unsafe.SkipInit(out Vector<T> result);
228Unsafe.SkipInit(out Vector<T> result);
248Unsafe.SkipInit(out Vector<ulong> result);
271Unsafe.SkipInit(out Vector<ulong> result);
293Unsafe.SkipInit(out Vector<T> result);
312Unsafe.SkipInit(out Vector<T> result);
350Unsafe.SkipInit(out Vector<ulong> result);
468Unsafe.SkipInit(out Vector<T> result);
487Unsafe.SkipInit(out Vector<T> result);
520Unsafe.SkipInit(out Vector<ulong> result);
541Unsafe.SkipInit(out Vector<T> result);
560Unsafe.SkipInit(out Vector<T> result);
611Unsafe.SkipInit(out Vector<T> result);
636Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), this);
660Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), this);
676Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), this);
690Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), this);
797Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), this);
812Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), this);
src\libraries\System.Private.CoreLib\src\System\Numerics\Vector2.cs (17)
411return Unsafe.ReadUnaligned<Vector2>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values)));
704ref readonly byte address = ref Unsafe.As<float, byte>(ref Unsafe.AsRef(in source));
705return Unsafe.ReadUnaligned<Vector2>(in address);
714ref readonly byte address = ref Unsafe.As<float, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
715return Unsafe.ReadUnaligned<Vector2>(in address);
974Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this);
1002Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this);
1016Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
1030Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
src\libraries\System.Private.CoreLib\src\System\Numerics\Vector3.cs (17)
446return Unsafe.ReadUnaligned<Vector3>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values)));
734ref readonly byte address = ref Unsafe.As<float, byte>(ref Unsafe.AsRef(in source));
735return Unsafe.ReadUnaligned<Vector3>(in address);
744ref readonly byte address = ref Unsafe.As<float, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
745return Unsafe.ReadUnaligned<Vector3>(in address);
984Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this);
1012Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this);
1026Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
1040Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);
src\libraries\System.Private.CoreLib\src\System\Numerics\VectorDebugView_1.cs (23)
23Unsafe.WriteUnaligned(ref items[0], _value);
33Unsafe.WriteUnaligned(ref Unsafe.As<double, byte>(ref items[0]), _value);
43Unsafe.WriteUnaligned(ref Unsafe.As<short, byte>(ref items[0]), _value);
53Unsafe.WriteUnaligned(ref Unsafe.As<int, byte>(ref items[0]), _value);
63Unsafe.WriteUnaligned(ref Unsafe.As<long, byte>(ref items[0]), _value);
73Unsafe.WriteUnaligned(ref Unsafe.As<nint, byte>(ref items[0]), _value);
83Unsafe.WriteUnaligned(ref Unsafe.As<nuint, byte>(ref items[0]), _value);
93Unsafe.WriteUnaligned(ref Unsafe.As<sbyte, byte>(ref items[0]), _value);
103Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref items[0]), _value);
113Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref items[0]), _value);
123Unsafe.WriteUnaligned(ref Unsafe.As<uint, byte>(ref items[0]), _value);
133Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref items[0]), _value);
src\libraries\System.Private.CoreLib\src\System\ReadOnlySpan.cs (9)
83_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */);
119_reference = ref Unsafe.AsRef(in reference);
150return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */);
227return new ReadOnlySpan<T>(ref Unsafe.As<TDerived, T>(ref items._reference), items.Length);
292ref T ret = ref Unsafe.NullRef<T>();
348Unsafe.AreSame(ref left._reference, ref right._reference);
358return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length));
376return new ReadOnlySpan<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start);
399return new ReadOnlySpan<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), length);
src\libraries\System.Private.CoreLib\src\System\Reflection\FieldAccessor.cs (30)
131return Volatile.Read(ref Unsafe.As<byte, object>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)));
142ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset));
148(void*)Unsafe.As<byte, IntPtr>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)),
152return Volatile.Read(ref Unsafe.As<IntPtr, object>(ref *(IntPtr*)_addressOrOffset));
159return RuntimeHelpers.Box(_methodTable, ref Unsafe.AsRef<byte>(_addressOrOffset.ToPointer()));
165ref Unsafe.As<IntPtr, object>(ref *(IntPtr*)_addressOrOffset).GetRawData());
168return Pointer.Box((void*)Unsafe.As<byte, IntPtr>(
169ref Unsafe.AsRef<byte>(_addressOrOffset.ToPointer())), _fieldInfo.FieldType);
223ref Unsafe.As<byte, object?>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)),
231ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset),
239ref Unsafe.As<byte, short>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)),
240Unsafe.As<byte, short>(ref value!.GetRawData()));
247ref Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)),
248Unsafe.As<byte, int>(ref value!.GetRawData()));
255ref Unsafe.As<byte, long>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)),
256Unsafe.As<byte, long>(ref value!.GetRawData()));
261Volatile.Write(ref Unsafe.As<IntPtr, object?>(ref *(IntPtr*)_addressOrOffset), value);
267ref Unsafe.AsRef<byte>(_addressOrOffset.ToPointer()),
274ref Unsafe.AsRef<short>(_addressOrOffset.ToPointer()),
275Unsafe.As<byte, short>(ref value!.GetRawData()));
281ref Unsafe.AsRef<int>(_addressOrOffset.ToPointer()),
282Unsafe.As<byte, int>(ref value!.GetRawData()));
288ref Unsafe.AsRef<long>(_addressOrOffset.ToPointer()),
289Unsafe.As<byte, long>(ref value!.GetRawData()));
src\libraries\System.Private.CoreLib\src\System\Reflection\InvokeUtils.cs (55)
138Unsafe.As<byte, ushort>(ref destElement) = srcElement; break;
141Unsafe.As<byte, uint>(ref destElement) = srcElement; break;
144Unsafe.As<byte, ulong>(ref destElement) = srcElement; break;
146Unsafe.As<byte, float>(ref destElement) = srcElement; break;
148Unsafe.As<byte, double>(ref destElement) = srcElement; break;
158Unsafe.As<byte, short>(ref destElement) = Unsafe.As<byte, sbyte>(ref srcElement); break;
160Unsafe.As<byte, int>(ref destElement) = Unsafe.As<byte, sbyte>(ref srcElement); break;
162Unsafe.As<byte, long>(ref destElement) = Unsafe.As<byte, sbyte>(ref srcElement); break;
164Unsafe.As<byte, float>(ref destElement) = Unsafe.As<byte, sbyte>(ref srcElement); break;
166Unsafe.As<byte, double>(ref destElement) = Unsafe.As<byte, sbyte>(ref srcElement); break;
179Unsafe.As<byte, ushort>(ref destElement) = Unsafe.As<byte, ushort>(ref srcElement); break;
182Unsafe.As<byte, uint>(ref destElement) = Unsafe.As<byte, ushort>(ref srcElement); break;
185Unsafe.As<byte, ulong>(ref destElement) = Unsafe.As<byte, ushort>(ref srcElement); break;
187Unsafe.As<byte, float>(ref destElement) = Unsafe.As<byte, ushort>(ref srcElement); break;
189Unsafe.As<byte, double>(ref destElement) = Unsafe.As<byte, ushort>(ref srcElement); break;
199Unsafe.As<byte, int>(ref destElement) = Unsafe.As<byte, short>(ref srcElement); break;
201Unsafe.As<byte, long>(ref destElement) = Unsafe.As<byte, short>(ref srcElement); break;
203Unsafe.As<byte, float>(ref destElement) = Unsafe.As<byte, short>(ref srcElement); break;
205Unsafe.As<byte, double>(ref destElement) = Unsafe.As<byte, short>(ref srcElement); break;
216Unsafe.As<byte, ulong>(ref destElement) = Unsafe.As<byte, uint>(ref srcElement); break;
218Unsafe.As<byte, float>(ref destElement) = Unsafe.As<byte, uint>(ref srcElement); break;
220Unsafe.As<byte, double>(ref destElement) = Unsafe.As<byte, uint>(ref srcElement); break;
230Unsafe.As<byte, long>(ref destElement) = Unsafe.As<byte, int>(ref srcElement); break;
232Unsafe.As<byte, float>(ref destElement) = Unsafe.As<byte, int>(ref srcElement); break;
234Unsafe.As<byte, double>(ref destElement) = Unsafe.As<byte, int>(ref srcElement); break;
244Unsafe.As<byte, float>(ref destElement) = Unsafe.As<byte, ulong>(ref srcElement); break;
246Unsafe.As<byte, double>(ref destElement) = Unsafe.As<byte, ulong>(ref srcElement); break;
256Unsafe.As<byte, float>(ref destElement) = Unsafe.As<byte, long>(ref srcElement); break;
258Unsafe.As<byte, double>(ref destElement) = Unsafe.As<byte, long>(ref srcElement); break;
266Unsafe.As<byte, double>(ref destElement) = Unsafe.As<byte, float>(ref srcElement); break;
src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\ConfiguredValueTaskAwaitable.cs (6)
63Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
85Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
105Unsafe.As<IValueTaskSource>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token,
168Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
190Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token,
210Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token,
src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\ValueTaskAwaiter.cs (6)
58Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext | ValueTaskSourceOnCompletedFlags.FlowExecutionContext);
78Unsafe.As<IValueTaskSource>(obj).OnCompleted(s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
97Unsafe.As<IValueTaskSource>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
140Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext | ValueTaskSourceOnCompletedFlags.FlowExecutionContext);
160Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
179Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token, ValueTaskSourceOnCompletedFlags.UseSchedulingContext);
src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\MemoryMarshal.cs (19)
37ref Unsafe.As<T, byte>(ref GetReference(span)),
60ref Unsafe.As<T, byte>(ref GetReference(span)),
93internal static unsafe ref T GetNonNullPinnableReference<T>(Span<T> span) => ref (span.Length != 0) ? ref Unsafe.AsRef(in span._reference) : ref Unsafe.AsRef<T>((void*)1);
100internal static unsafe ref T GetNonNullPinnableReference<T>(ReadOnlySpan<T> span) => ref (span.Length != 0) ? ref Unsafe.AsRef(in span._reference) : ref Unsafe.AsRef<T>((void*)1);
153ref Unsafe.As<TFrom, TTo>(ref span._reference),
208ref Unsafe.As<TFrom, TTo>(ref GetReference(span)),
227new Span<T>(ref Unsafe.AsRef(in reference), length);
244new ReadOnlySpan<T>(ref Unsafe.AsRef(in reference), length);
290segment = new ArraySegment<T>(Unsafe.As<T[]>(obj), index & ReadOnlyMemory<T>.RemoveFlagsBitMask, length);
299if (Unsafe.As<MemoryManager<T>>(obj).TryGetArray(out ArraySegment<T> tempArraySegment))
411T[] array = Unsafe.As<T[]>(obj);
479return Unsafe.ReadUnaligned<T>(ref GetReference(source));
499value = Unsafe.ReadUnaligned<T>(ref GetReference(source));
518Unsafe.WriteUnaligned(ref GetReference(destination), value);
537Unsafe.WriteUnaligned(ref GetReference(destination), value);
561return ref Unsafe.As<byte, T>(ref GetReference(span));
583return ref Unsafe.As<byte, T>(ref GetReference(span));
src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NFloat.cs (16)
697Unsafe.SkipInit(out result);
698return NativeType.TryParse(s, out Unsafe.As<NFloat, NativeType>(ref result));
707Unsafe.SkipInit(out result);
708return NativeType.TryParse(s, out Unsafe.As<NFloat, NativeType>(ref result));
717Unsafe.SkipInit(out result);
718return NativeType.TryParse(utf8Text, out Unsafe.As<NFloat, NativeType>(ref result));
734Unsafe.SkipInit(out result);
735return NativeType.TryParse(s, style, provider, out Unsafe.As<NFloat, NativeType>(ref result));
751Unsafe.SkipInit(out result);
752return NativeType.TryParse(s, style, provider, out Unsafe.As<NFloat, NativeType>(ref result));
1052Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
1076Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent);
1100Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);
1124Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);
1922Unsafe.SkipInit(out result);
1923return NativeType.TryParse(utf8Text, style, provider, out Unsafe.As<NFloat, NativeType>(ref result));
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.cs (56)
267return Unsafe.BitCast<Vector128<TFrom>, Vector128<TTo>>(vector);
651Unsafe.SkipInit(out Vector128<float> result);
762Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
789Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
806Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
990return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref values[0]));
1011return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref values[index]));
1028return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
1255Unsafe.SkipInit(out Vector128<T> result);
1441Unsafe.SkipInit(out Vector128<T> result);
2362ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
2363return Unsafe.ReadUnaligned<Vector128<T>>(in address);
2378ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2379return Unsafe.ReadUnaligned<Vector128<T>>(in address);
2385internal static Vector128<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source));
2391internal static Vector128<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset);
2706Unsafe.SkipInit(out Vector128<TResult> result);
2803Unsafe.SkipInit(out Vector128<TResult> result);
3323Unsafe.SkipInit(out Vector128<byte> result);
3368Unsafe.SkipInit(out Vector128<sbyte> result);
3445Unsafe.SkipInit(out Vector128<short> result);
3470Unsafe.SkipInit(out Vector128<ushort> result);
3533Unsafe.SkipInit(out Vector128<int> result);
3558Unsafe.SkipInit(out Vector128<uint> result);
3582Unsafe.SkipInit(out Vector128<float> result);
3664Unsafe.SkipInit(out Vector128<long> result);
3689Unsafe.SkipInit(out Vector128<ulong> result);
3713Unsafe.SkipInit(out Vector128<double> result);
3942ref byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref destination, elementOffset));
3943Unsafe.WriteUnaligned(ref address, source.AsDouble().ToScalar());
3956ref byte address = ref Unsafe.As<T, byte>(ref destination);
3957Unsafe.WriteUnaligned(ref address, source);
3972destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
3973Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
4068Unsafe.SkipInit(out Vector256<T> result);
4121Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
4458ref T address = ref Unsafe.As<Vector128<T>, T>(ref Unsafe.AsRef(in vector));
4459return Unsafe.Add(ref address, index);
4466ref T address = ref Unsafe.As<Vector128<T>, T>(ref Unsafe.AsRef(in vector));
4467Unsafe.Add(ref address, index) = value;
4471internal static void SetLowerUnsafe<T>(in this Vector128<T> vector, Vector64<T> value) => Unsafe.AsRef(in vector._lower) = value;
4474internal static void SetUpperUnsafe<T>(in this Vector128<T> vector, Vector64<T> value) => Unsafe.AsRef(in vector._upper) = value;
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.Numerics.cs (20)
56public static Plane AsPlane(this Vector128<float> value) => Unsafe.BitCast<Vector128<float>, Plane>(value);
62public static Quaternion AsQuaternion(this Vector128<float> value) => Unsafe.BitCast<Vector128<float>, Quaternion>(value);
68public static Vector128<float> AsVector128(this Plane value) => Unsafe.BitCast<Plane, Vector128<float>>(value);
74public static Vector128<float> AsVector128(this Quaternion value) => Unsafe.BitCast<Quaternion, Vector128<float>>(value);
92public static Vector128<float> AsVector128(this Vector4 value) => Unsafe.BitCast<Vector4, Vector128<float>>(value);
106ref byte address = ref Unsafe.As<Vector<T>, byte>(ref value);
107return Unsafe.ReadUnaligned<Vector128<T>>(ref address);
119Unsafe.SkipInit(out Vector128<float> result);
120Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<float>, byte>(ref result), value);
133Unsafe.SkipInit(out Vector128<float> result);
134Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<float>, byte>(ref result), value);
145ref byte address = ref Unsafe.As<Vector128<float>, byte>(ref value);
146return Unsafe.ReadUnaligned<Vector2>(ref address);
156ref byte address = ref Unsafe.As<Vector128<float>, byte>(ref value);
157return Unsafe.ReadUnaligned<Vector3>(ref address);
164public static Vector4 AsVector4(this Vector128<float> value) => Unsafe.BitCast<Vector128<float>, Vector4>(value);
179Unsafe.WriteUnaligned(ref Unsafe.As<Vector<T>, byte>(ref result), value);
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128DebugView_1.cs (23)
22Unsafe.WriteUnaligned(ref items[0], _value);
32Unsafe.WriteUnaligned(ref Unsafe.As<double, byte>(ref items[0]), _value);
42Unsafe.WriteUnaligned(ref Unsafe.As<short, byte>(ref items[0]), _value);
52Unsafe.WriteUnaligned(ref Unsafe.As<int, byte>(ref items[0]), _value);
62Unsafe.WriteUnaligned(ref Unsafe.As<long, byte>(ref items[0]), _value);
72Unsafe.WriteUnaligned(ref Unsafe.As<nint, byte>(ref items[0]), _value);
82Unsafe.WriteUnaligned(ref Unsafe.As<nuint, byte>(ref items[0]), _value);
92Unsafe.WriteUnaligned(ref Unsafe.As<sbyte, byte>(ref items[0]), _value);
102Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref items[0]), _value);
112Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref items[0]), _value);
122Unsafe.WriteUnaligned(ref Unsafe.As<uint, byte>(ref items[0]), _value);
132Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref items[0]), _value);
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256.cs (60)
252return Unsafe.BitCast<Vector256<TFrom>, Vector256<TTo>>(vector);
369ref byte address = ref Unsafe.As<Vector<T>, byte>(ref value);
370return Unsafe.ReadUnaligned<Vector256<T>>(ref address);
375Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<T>, byte>(ref result), value);
393ref byte address = ref Unsafe.As<Vector256<T>, byte>(ref value);
394return Unsafe.ReadUnaligned<Vector<T>>(ref address);
399Unsafe.WriteUnaligned(ref Unsafe.As<Vector<T>, byte>(ref result), value);
769Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
796Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
813Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
997return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[0]));
1018return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[index]));
1035return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
1339Unsafe.SkipInit(out Vector256<T> result);
1527Unsafe.SkipInit(out Vector256<T> result);
2446ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
2447return Unsafe.ReadUnaligned<Vector256<T>>(in address);
2462ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2463return Unsafe.ReadUnaligned<Vector256<T>>(in address);
2469internal static Vector256<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source));
2475internal static Vector256<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset);
2790Unsafe.SkipInit(out Vector256<TResult> result);
2859Unsafe.SkipInit(out Vector256<TResult> result);
3338Unsafe.SkipInit(out Vector256<byte> result);
3363Unsafe.SkipInit(out Vector256<sbyte> result);
3428Unsafe.SkipInit(out Vector256<short> result);
3453Unsafe.SkipInit(out Vector256<ushort> result);
3516Unsafe.SkipInit(out Vector256<int> result);
3541Unsafe.SkipInit(out Vector256<uint> result);
3565Unsafe.SkipInit(out Vector256<float> result);
3647Unsafe.SkipInit(out Vector256<long> result);
3672Unsafe.SkipInit(out Vector256<ulong> result);
3696Unsafe.SkipInit(out Vector256<double> result);
3923ref byte address = ref Unsafe.As<T, byte>(ref destination);
3924Unsafe.WriteUnaligned(ref address, source);
3939destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
3940Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
4023Unsafe.SkipInit(out Vector512<T> result);
4076Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
4411ref T address = ref Unsafe.As<Vector256<T>, T>(ref Unsafe.AsRef(in vector));
4412return Unsafe.Add(ref address, index);
4419ref T address = ref Unsafe.As<Vector256<T>, T>(ref Unsafe.AsRef(in vector));
4420Unsafe.Add(ref address, index) = value;
4423internal static void SetLowerUnsafe<T>(in this Vector256<T> vector, Vector128<T> value) => Unsafe.AsRef(in vector._lower) = value;
4425internal static void SetUpperUnsafe<T>(in this Vector256<T> vector, Vector128<T> value) => Unsafe.AsRef(in vector._upper) = value;
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256DebugView_1.cs (23)
22Unsafe.WriteUnaligned(ref items[0], _value);
32Unsafe.WriteUnaligned(ref Unsafe.As<double, byte>(ref items[0]), _value);
42Unsafe.WriteUnaligned(ref Unsafe.As<short, byte>(ref items[0]), _value);
52Unsafe.WriteUnaligned(ref Unsafe.As<int, byte>(ref items[0]), _value);
62Unsafe.WriteUnaligned(ref Unsafe.As<long, byte>(ref items[0]), _value);
72Unsafe.WriteUnaligned(ref Unsafe.As<nint, byte>(ref items[0]), _value);
82Unsafe.WriteUnaligned(ref Unsafe.As<nuint, byte>(ref items[0]), _value);
92Unsafe.WriteUnaligned(ref Unsafe.As<sbyte, byte>(ref items[0]), _value);
102Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref items[0]), _value);
112Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref items[0]), _value);
122Unsafe.WriteUnaligned(ref Unsafe.As<uint, byte>(ref items[0]), _value);
132Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref items[0]), _value);
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512.cs (55)
251return Unsafe.BitCast<Vector512<TFrom>, Vector512<TTo>>(vector);
368Unsafe.WriteUnaligned(ref Unsafe.As<Vector512<T>, byte>(ref result), value);
384ref byte address = ref Unsafe.As<Vector512<T>, byte>(ref value);
385return Unsafe.ReadUnaligned<Vector<T>>(ref address);
681Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
707Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
723Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
899return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[0]));
919return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[index]));
936return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
1379Unsafe.SkipInit(out Vector512<T> result);
1566Unsafe.SkipInit(out Vector512<T> result);
2472ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
2473return Unsafe.ReadUnaligned<Vector512<T>>(in address);
2488ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2489return Unsafe.ReadUnaligned<Vector512<T>>(in address);
2495internal static Vector512<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source));
2501internal static Vector512<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset);
2815Unsafe.SkipInit(out Vector512<TResult> result);
2884Unsafe.SkipInit(out Vector512<TResult> result);
3363Unsafe.SkipInit(out Vector512<byte> result);
3388Unsafe.SkipInit(out Vector512<sbyte> result);
3453Unsafe.SkipInit(out Vector512<short> result);
3478Unsafe.SkipInit(out Vector512<ushort> result);
3541Unsafe.SkipInit(out Vector512<int> result);
3566Unsafe.SkipInit(out Vector512<uint> result);
3590Unsafe.SkipInit(out Vector512<float> result);
3672Unsafe.SkipInit(out Vector512<long> result);
3697Unsafe.SkipInit(out Vector512<ulong> result);
3721Unsafe.SkipInit(out Vector512<double> result);
3934ref byte address = ref Unsafe.As<T, byte>(ref destination);
3935Unsafe.WriteUnaligned(ref address, source);
3950destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
3951Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
4053Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
4388ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector));
4389return Unsafe.Add(ref address, index);
4396ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector));
4397Unsafe.Add(ref address, index) = value;
4400internal static void SetLowerUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._lower) = value;
4402internal static void SetUpperUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._upper) = value;
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512DebugView_1.cs (23)
22Unsafe.WriteUnaligned(ref items[0], _value);
32Unsafe.WriteUnaligned(ref Unsafe.As<double, byte>(ref items[0]), _value);
42Unsafe.WriteUnaligned(ref Unsafe.As<short, byte>(ref items[0]), _value);
52Unsafe.WriteUnaligned(ref Unsafe.As<int, byte>(ref items[0]), _value);
62Unsafe.WriteUnaligned(ref Unsafe.As<long, byte>(ref items[0]), _value);
72Unsafe.WriteUnaligned(ref Unsafe.As<nint, byte>(ref items[0]), _value);
82Unsafe.WriteUnaligned(ref Unsafe.As<nuint, byte>(ref items[0]), _value);
92Unsafe.WriteUnaligned(ref Unsafe.As<sbyte, byte>(ref items[0]), _value);
102Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref items[0]), _value);
112Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref items[0]), _value);
122Unsafe.WriteUnaligned(ref Unsafe.As<uint, byte>(ref items[0]), _value);
132Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref items[0]), _value);
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64.cs (120)
124Unsafe.SkipInit(out Vector64<T> result);
151Unsafe.SkipInit(out Vector64<T> result);
251return Unsafe.BitCast<Vector64<TFrom>, Vector64<TTo>>(vector);
395Unsafe.SkipInit(out Vector64<T> result);
456Unsafe.SkipInit(out Vector64<double> result);
475Unsafe.SkipInit(out Vector64<double> result);
493Unsafe.SkipInit(out Vector64<int> result);
511Unsafe.SkipInit(out Vector64<int> result);
529Unsafe.SkipInit(out Vector64<long> result);
547Unsafe.SkipInit(out Vector64<long> result);
565Unsafe.SkipInit(out Vector64<float> result);
584Unsafe.SkipInit(out Vector64<float> result);
603Unsafe.SkipInit(out Vector64<uint> result);
622Unsafe.SkipInit(out Vector64<uint> result);
641Unsafe.SkipInit(out Vector64<ulong> result);
660Unsafe.SkipInit(out Vector64<ulong> result);
690Unsafe.SkipInit(out Vector64<T> result);
719Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
746Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
763Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
769Unsafe.SkipInit(out Vector64<T> result);
860Unsafe.SkipInit(out Vector64<T> result);
970return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref values[0]));
991return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref values[index]));
1008return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
1026Unsafe.SkipInit(out Vector64<byte> result);
1049Unsafe.SkipInit(out Vector64<short> result);
1066Unsafe.SkipInit(out Vector64<int> result);
1088Unsafe.SkipInit(out Vector64<sbyte> result);
1108Unsafe.SkipInit(out Vector64<float> result);
1126Unsafe.SkipInit(out Vector64<ushort> result);
1144Unsafe.SkipInit(out Vector64<uint> result);
1254Unsafe.SkipInit(out Vector64<T> result);
1349Unsafe.SkipInit(out Vector64<T> result);
1430Unsafe.SkipInit(out Vector64<T> result);
1474Unsafe.SkipInit(out Vector64<T> result);
1567Unsafe.SkipInit(out Vector64<T> result);
1606Unsafe.SkipInit(out Vector64<double> result);
1630Unsafe.SkipInit(out Vector64<float> result);
1670Unsafe.SkipInit(out Vector64<T> result);
1733Unsafe.SkipInit(out Vector64<T> result);
1789Unsafe.SkipInit(out Vector64<T> result);
2121Unsafe.SkipInit(out Vector64<T> result);
2180Unsafe.SkipInit(out Vector64<T> result);
2243Unsafe.SkipInit(out Vector64<T> result);
2345ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
2346return Unsafe.ReadUnaligned<Vector64<T>>(in address);
2361ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2362return Unsafe.ReadUnaligned<Vector64<T>>(in address);
2368Unsafe.SkipInit(out Vector64<T> result);
2414Unsafe.SkipInit(out Vector64<T> result);
2468Unsafe.SkipInit(out Vector64<T> result);
2491Unsafe.SkipInit(out Vector64<T> result);
2514Unsafe.SkipInit(out Vector64<T> result);
2537Unsafe.SkipInit(out Vector64<T> result);
2560Unsafe.SkipInit(out Vector64<T> result);
2583Unsafe.SkipInit(out Vector64<T> result);
2606Unsafe.SkipInit(out Vector64<T> result);
2629Unsafe.SkipInit(out Vector64<T> result);
2652Unsafe.SkipInit(out Vector64<T> result);
2675Unsafe.SkipInit(out Vector64<T> result);
2718Unsafe.SkipInit(out Vector64<T> result);
2742Unsafe.SkipInit(out Vector64<double> result);
2766Unsafe.SkipInit(out Vector64<float> result);
2783Unsafe.SkipInit(out Vector64<TResult> result);
2852Unsafe.SkipInit(out Vector64<TResult> result);
2967Unsafe.SkipInit(out Vector64<T> result);
3031Unsafe.SkipInit(out Vector64<T> result);
3142Unsafe.SkipInit(out Vector64<uint> result);
3164Unsafe.SkipInit(out Vector64<ulong> result);
3355Unsafe.SkipInit(out Vector64<byte> result);
3380Unsafe.SkipInit(out Vector64<sbyte> result);
3445Unsafe.SkipInit(out Vector64<short> result);
3470Unsafe.SkipInit(out Vector64<ushort> result);
3533Unsafe.SkipInit(out Vector64<int> result);
3558Unsafe.SkipInit(out Vector64<uint> result);
3582Unsafe.SkipInit(out Vector64<float> result);
3660Unsafe.SkipInit(out Vector64<T> result);
3713Unsafe.SkipInit(out Vector64<T> sinResult);
3714Unsafe.SkipInit(out Vector64<T> cosResult);
3774Unsafe.SkipInit(out Vector64<T> result);
3834ref byte address = ref Unsafe.As<T, byte>(ref destination);
3835Unsafe.WriteUnaligned(ref address, source);
3850destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
3851Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
3869Unsafe.SkipInit(out Vector64<T> result);
3942Unsafe.SkipInit(out Vector128<T> result);
3966Unsafe.SkipInit(out Vector64<T> result);
4000Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
4058Unsafe.SkipInit(out Vector64<ushort> lower);
4076Unsafe.SkipInit(out Vector64<int> lower);
4094Unsafe.SkipInit(out Vector64<long> lower);
4113Unsafe.SkipInit(out Vector64<short> lower);
4131Unsafe.SkipInit(out Vector64<double> lower);
4150Unsafe.SkipInit(out Vector64<uint> lower);
4169Unsafe.SkipInit(out Vector64<ulong> lower);
4188Unsafe.SkipInit(out Vector64<ushort> upper);
4206Unsafe.SkipInit(out Vector64<int> upper);
4224Unsafe.SkipInit(out Vector64<long> upper);
4243Unsafe.SkipInit(out Vector64<short> upper);
4261Unsafe.SkipInit(out Vector64<double> upper);
4280Unsafe.SkipInit(out Vector64<uint> upper);
4299Unsafe.SkipInit(out Vector64<ulong> upper);
4345ref T address = ref Unsafe.As<Vector64<T>, T>(ref Unsafe.AsRef(in vector));
4346return Unsafe.Add(ref address, index);
4353ref T address = ref Unsafe.As<Vector64<T>, T>(ref Unsafe.AsRef(in vector));
4354Unsafe.Add(ref address, index) = value;
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64DebugView_1.cs (23)
22Unsafe.WriteUnaligned(ref items[0], _value);
32Unsafe.WriteUnaligned(ref Unsafe.As<double, byte>(ref items[0]), _value);
42Unsafe.WriteUnaligned(ref Unsafe.As<short, byte>(ref items[0]), _value);
52Unsafe.WriteUnaligned(ref Unsafe.As<int, byte>(ref items[0]), _value);
62Unsafe.WriteUnaligned(ref Unsafe.As<long, byte>(ref items[0]), _value);
72Unsafe.WriteUnaligned(ref Unsafe.As<nint, byte>(ref items[0]), _value);
82Unsafe.WriteUnaligned(ref Unsafe.As<nuint, byte>(ref items[0]), _value);
92Unsafe.WriteUnaligned(ref Unsafe.As<sbyte, byte>(ref items[0]), _value);
102Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref items[0]), _value);
112Unsafe.WriteUnaligned(ref Unsafe.As<ushort, byte>(ref items[0]), _value);
122Unsafe.WriteUnaligned(ref Unsafe.As<uint, byte>(ref items[0]), _value);
132Unsafe.WriteUnaligned(ref Unsafe.As<ulong, byte>(ref items[0]), _value);
src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\VectorMath.cs (113)
79TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax);
114Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)),
120Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)),
131Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))),
217TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax);
274Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))),
288Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)),
294Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)),
412if (TVectorUInt64.LessThanOrEqualAll(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(x)), TVectorUInt64.Create(V_ARG_MAX)))
418TVectorUInt64 n = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(dn);
455return poly * Unsafe.BitCast<TVectorUInt64, TVectorDouble>((n + TVectorUInt64.Create(V_DP64_BIAS)) << 52);
543if (TVectorUInt32.GreaterThanAny(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(x)), TVectorUInt32.Create(V_ARG_MAX)))
570TVectorUInt64 n = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(dn);
589return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(poly) + (n << 52));
609TVectorUInt64 xBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ax);
610TVectorUInt64 yBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ay);
619TVectorDouble insignificanMask = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(
628TVectorDouble expFix = TVectorDouble.ConditionalSelect(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(scaleDownMask), TVectorDouble.Create(4.149515568880993E+180), TVectorDouble.One);
634expFix = TVectorDouble.ConditionalSelect(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(scaleUpMask), TVectorDouble.Create(2.409919865102884E-181), expFix);
649ax = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xBits);
650ax -= subnormalFix & Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xSubnormalMask);
654ay = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(yBits);
655ay -= subnormalFix & Unsafe.BitCast<TVectorUInt64, TVectorDouble>(ySubnormalMask);
657xBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ax);
658yBits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(ay);
668xBits = TVectorUInt64.ConditionalSelect(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(lessThanMask), yBits, xBits);
669yBits = TVectorUInt64.ConditionalSelect(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(lessThanMask), tmpBits, yBits);
676TVectorDouble xHead = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(xBits & headMask);
677TVectorDouble yHead = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(yBits & headMask);
699TVectorDouble equalExponentsMask = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(TVectorUInt64.IsZero(expDiff));
777TVectorUInt32 bits = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(vector));
794return Unsafe.BitCast<TVectorUInt32, TVectorSingle>(result);
802TVectorUInt64 bits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(vector));
819return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(result);
827TVectorUInt32 bits = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(TVectorSingle.Abs(vector));
840return Unsafe.BitCast<TVectorUInt32, TVectorSingle>(result);
848TVectorUInt64 bits = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(TVectorDouble.Abs(vector));
861return Unsafe.BitCast<TVectorUInt64, TVectorDouble>(result);
934TVectorUInt64 specialMask = TVectorUInt64.GreaterThanOrEqual(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_MIN), TVectorUInt64.Create(V_MAX - V_MIN));
963TVectorDouble subnormalMask = TVectorDouble.AndNot(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), temp);
968Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x * 4503599627370496.0) - TVectorUInt64.Create(52ul << 52)),
972specialMask = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(temp);
976TVectorUInt64 vx = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_OFF);
977TVectorDouble n = ConvertToDouble<TVectorInt64, TVectorDouble>(Unsafe.BitCast<TVectorUInt64, TVectorInt64>(vx) >> 52);
981TVectorDouble r = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(vx) - TVectorDouble.One;
1028Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask),
1115TVectorUInt32 specialMask = TVectorUInt32.GreaterThanOrEqual(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_MIN), TVectorUInt32.Create(V_MAX - V_MIN));
1144TVectorSingle subnormalMask = TVectorSingle.AndNot(Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), temp);
1148Unsafe.BitCast<TVectorUInt32, TVectorSingle>(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x * 8388608.0f) - TVectorUInt32.Create(23u << 23)),
1152specialMask = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(temp);
1155TVectorUInt32 vx = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_OFF);
1156TVectorSingle n = ConvertToSingle<TVectorInt32, TVectorSingle>(Unsafe.BitCast<TVectorUInt32, TVectorInt32>(vx) >> 23);
1160TVectorSingle r = Unsafe.BitCast<TVectorUInt32, TVectorSingle>(vx) - TVectorSingle.Create(1.0f);
1187Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask),
1254TVectorUInt64 specialMask = TVectorUInt64.GreaterThanOrEqual(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_MIN), TVectorUInt64.Create(V_MAX - V_MIN));
1283TVectorDouble subnormalMask = TVectorDouble.AndNot(Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask), temp);
1288Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x * 4503599627370496.0) - TVectorUInt64.Create(52ul << 52)),
1292specialMask = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(temp);
1296TVectorUInt64 vx = Unsafe.BitCast<TVectorDouble, TVectorUInt64>(x) - TVectorUInt64.Create(V_OFF);
1297TVectorDouble n = ConvertToDouble<TVectorInt64, TVectorDouble>(Unsafe.BitCast<TVectorUInt64, TVectorInt64>(vx) >> 52);
1301TVectorDouble r = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(vx) - TVectorDouble.One;
1348Unsafe.BitCast<TVectorUInt64, TVectorDouble>(specialMask),
1431TVectorUInt32 specialMask = TVectorUInt32.GreaterThanOrEqual(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_MIN), TVectorUInt32.Create(V_MAX - V_MIN));
1460TVectorSingle subnormalMask = TVectorSingle.AndNot(Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask), temp);
1465Unsafe.BitCast<TVectorUInt32, TVectorSingle>(Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x * 8388608.0f) - TVectorUInt32.Create(23u << 23)),
1469specialMask = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(temp);
1473TVectorUInt32 vx = Unsafe.BitCast<TVectorSingle, TVectorUInt32>(x) - TVectorUInt32.Create(V_OFF);
1474TVectorSingle n = ConvertToSingle<TVectorInt32, TVectorSingle>(Unsafe.BitCast<TVectorUInt32, TVectorInt32>(vx) >> 23);
1478TVectorSingle r = Unsafe.BitCast<TVectorUInt32, TVectorSingle>(vx) - TVectorSingle.One;
1505Unsafe.BitCast<TVectorUInt32, TVectorSingle>(specialMask),
1804TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax);
1843Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)),
1849Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)),
1854TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63;
1857Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)),
1863Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)),
1874Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))),
1880Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))),
1923TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax);
1998Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))),
2004Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))),
2020Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)),
2026Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)),
2031TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63;
2034Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)),
2040Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals((region + TVectorInt64.One) & TVectorInt64.Create(2), TVectorInt64.Zero)),
2124TVectorInt64 ux = Unsafe.BitCast<TVectorDouble, TVectorInt64>(ax);
2154Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)),
2159TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63;
2162Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)),
2173Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.GreaterThan(ux, TVectorInt64.Create(ARG_SMALLER - 1))),
2254TVectorInt32 ux = Unsafe.BitCast<TVectorSingle, TVectorInt32>(ax);
2311Unsafe.BitCast<TVectorInt32, TVectorSingle>(TVectorInt32.GreaterThan(ux, TVectorInt32.Create(ARG_SMALLER - 1))),
2326Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(region & TVectorInt64.One, TVectorInt64.Zero)),
2331TVectorInt64 sign = Unsafe.BitCast<TVectorDouble, TVectorInt64>(x) >>> 63;
2334Unsafe.BitCast<TVectorInt64, TVectorDouble>(TVectorInt64.Equals(((sign & (region >>> 1)) | (~sign & ~(region >>> 1))) & TVectorInt64.One, TVectorInt64.Zero)),
2359Unsafe.SkipInit(out TVectorDouble result);
2394Unsafe.SkipInit(out TVectorSingle result);
2518Unsafe.SkipInit(out TVector result);
2552Unsafe.SkipInit(out TVector result);
2587Unsafe.SkipInit(out TVectorSingle result);
2648Unsafe.SkipInit(out TVectorSingle result);
2687Unsafe.SkipInit(out TVectorUInt32 result);
2736Unsafe.SkipInit(out TVectorUInt64 result);
2885TVectorInt64 region = Unsafe.BitCast<TVectorDouble, TVectorInt64>(npi2);
2904Unsafe.SkipInit(out TVectorDouble result);
2978Unsafe.SkipInit(out TVectorDouble result);
3018Unsafe.SkipInit(out TVectorDouble result);
src\libraries\System.Private.CoreLib\src\System\SearchValues\Any1SearchValues.cs (4)
36SpanHelpers.NonPackedIndexOfValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length);
40SpanHelpers.NonPackedIndexOfValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length);
44SpanHelpers.LastIndexOfValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length);
48SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length);
src\libraries\System.Private.CoreLib\src\System\SearchValues\Any2SearchValues.cs (4)
36SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length);
40SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length);
44SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length);
48SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length);
src\libraries\System.Private.CoreLib\src\System\SearchValues\Any3SearchValues.cs (4)
36SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length);
40SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length);
44SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length);
48SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length);
src\libraries\System.Private.CoreLib\src\System\SearchValues\Any4SearchValues.cs (4)
39SpanHelpers.IndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length);
43SpanHelpers.IndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length);
47SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length);
51SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length);
src\libraries\System.Private.CoreLib\src\System\SearchValues\Any5SearchValues.cs (4)
40SpanHelpers.IndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length);
44SpanHelpers.IndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length);
48SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length);
52SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length);
src\libraries\System.Private.CoreLib\src\System\SearchValues\AsciiCharSearchValues.cs (6)
50ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);
58ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);
66ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);
74ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);
82ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);
90ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);
src\libraries\System.Private.CoreLib\src\System\SearchValues\IndexOfAnyAsciiSearcher.cs (102)
193TryIndexOfAny<DontNegate>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, asciiValues, out index);
197TryIndexOfAny<Negate>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, asciiValues, out index);
201TryLastIndexOfAny<DontNegate>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, asciiValues, out index);
205TryLastIndexOfAny<Negate>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, asciiValues, out index);
295ref short searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
297while (!Unsafe.AreSame(ref currentSearchSpace, ref searchSpaceEnd))
305currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 1);
325ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - (2 * Vector256<short>.Count));
338currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count);
340while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
347ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<short>.Count);
349ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
378ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - (2 * Vector128<short>.Count));
391currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector128<short>.Count);
393while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
400ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<short>.Count);
402ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
431char c = (char)Unsafe.Add(ref searchSpace, i);
441ref short currentSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
457ref short twoVectorsAfterStart = ref Unsafe.Add(ref searchSpace, 2 * Vector256<short>.Count);
461currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, 2 * Vector256<short>.Count);
472while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref twoVectorsAfterStart));
479ref short oneVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<short>.Count);
481ref short secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAfterStart)
482? ref Unsafe.Subtract(ref currentSearchSpace, Vector256<short>.Count)
508ref short twoVectorsAfterStart = ref Unsafe.Add(ref searchSpace, 2 * Vector128<short>.Count);
512currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, 2 * Vector128<short>.Count);
523while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref twoVectorsAfterStart));
530ref short oneVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<short>.Count);
532ref short secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAfterStart)
533? ref Unsafe.Subtract(ref currentSearchSpace, Vector128<short>.Count)
580ref byte searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
582while (!Unsafe.AreSame(ref currentSearchSpace, ref searchSpaceEnd))
590currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 1);
608ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<byte>.Count);
620currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<byte>.Count);
622while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref vectorAwayFromEnd));
629ref byte halfVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<byte>.Count);
631ref byte firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAwayFromEnd)
657ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<byte>.Count);
669currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<byte>.Count);
671while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref vectorAwayFromEnd));
678ref byte halfVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - sizeof(ulong));
680ref byte firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAwayFromEnd)
684ulong source0 = Unsafe.ReadUnaligned<ulong>(ref firstVector);
685ulong source1 = Unsafe.ReadUnaligned<ulong>(ref halfVectorAwayFromEnd);
709byte b = Unsafe.Add(ref searchSpace, i);
719ref byte currentSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
733ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count);
737currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector256<byte>.Count);
747while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref vectorAfterStart));
754ref byte halfVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<byte>.Count);
756ref byte secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAfterStart)
757? ref Unsafe.Subtract(ref currentSearchSpace, Vector128<byte>.Count)
782ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<byte>.Count);
786currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector128<byte>.Count);
796while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref vectorAfterStart));
803ref byte halfVectorAfterStart = ref Unsafe.Add(ref searchSpace, sizeof(ulong));
805ref byte secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAfterStart)
806? ref Unsafe.Subtract(ref currentSearchSpace, sizeof(ulong))
809ulong source0 = Unsafe.ReadUnaligned<ulong>(ref searchSpace);
810ulong source1 = Unsafe.ReadUnaligned<ulong>(ref secondVector);
851ref byte searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
853while (!Unsafe.AreSame(ref currentSearchSpace, ref searchSpaceEnd))
861currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 1);
880ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<byte>.Count);
892currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<byte>.Count);
894while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref vectorAwayFromEnd));
901ref byte halfVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<byte>.Count);
903ref byte firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAwayFromEnd)
932ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<byte>.Count);
944currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<byte>.Count);
946while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref vectorAwayFromEnd));
953ref byte halfVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - sizeof(ulong));
955ref byte firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAwayFromEnd)
959ulong source0 = Unsafe.ReadUnaligned<ulong>(ref firstVector);
960ulong source1 = Unsafe.ReadUnaligned<ulong>(ref halfVectorAwayFromEnd);
983byte b = Unsafe.Add(ref searchSpace, i);
993ref byte currentSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
1008ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count);
1012currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector256<byte>.Count);
1022while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref vectorAfterStart));
1029ref byte halfVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<byte>.Count);
1031ref byte secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAfterStart)
1032? ref Unsafe.Subtract(ref currentSearchSpace, Vector128<byte>.Count)
1060ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<byte>.Count);
1064currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector128<byte>.Count);
1074while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref vectorAfterStart));
1081ref byte halfVectorAfterStart = ref Unsafe.Add(ref searchSpace, sizeof(ulong));
1083ref byte secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAfterStart)
1084? ref Unsafe.Subtract(ref currentSearchSpace, sizeof(ulong))
1087ulong source0 = Unsafe.ReadUnaligned<ulong>(ref searchSpace);
1088ulong source1 = Unsafe.ReadUnaligned<ulong>(ref secondVector);
1257return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
1272return offsetInVector - Vector128<short>.Count + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref secondVector) / (nuint)sizeof(T));
1288return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
1310return offsetInVector - Vector256<short>.Count + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref secondVector) / (nuint)sizeof(T));
1464return (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
1472return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
1487return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
1501return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current0) / (nuint)sizeof(T));
1522return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current0) / (nuint)sizeof(T));
src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticMap.cs (69)
85Unsafe.Add(ref Unsafe.As<uint, byte>(ref charMap), value & VectorizedIndexMask) |= (byte)(1u << (value >> VectorizedIndexShift));
89Unsafe.Add(ref charMap, value & PortableIndexMask) |= 1u << (value >> PortableIndexShift);
96? (Unsafe.Add(ref Unsafe.As<uint, byte>(ref charMap), value & VectorizedIndexMask) & (1u << (value >> VectorizedIndexShift))) != 0
97: (Unsafe.Add(ref charMap, value & PortableIndexMask) & (1u << (value >> PortableIndexShift))) != 0;
108ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(values)),
426ref char searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
428Vector256<byte> charMap256 = Vector256.LoadUnsafe(ref Unsafe.As<ProbabilisticMap, byte>(ref state.Map));
437ref char lastStartVector = ref Unsafe.Subtract(ref searchSpaceEnd, 64);
441Vector512<byte> result = ContainsMask64CharsAvx512(charMap512, ref cur, ref Unsafe.Add(ref cur, Vector512<ushort>.Count));
451cur = ref Unsafe.Add(ref cur, 64);
453if (Unsafe.IsAddressGreaterThan(ref cur, ref lastStartVector))
455if (Unsafe.AreSame(ref cur, ref searchSpaceEnd))
471Vector512<byte> result = ContainsMask64CharsAvx512(charMap512, ref searchSpace, ref Unsafe.Subtract(ref searchSpaceEnd, Vector512<ushort>.Count));
488Vector256<byte> result = ContainsMask32CharsAvx512(charMap256, ref searchSpace, ref Unsafe.Subtract(ref searchSpaceEnd, Vector256<ushort>.Count));
510ref char searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
513Vector128<byte> charMapLower = Vector128.LoadUnsafe(ref Unsafe.As<ProbabilisticMap, byte>(ref state.Map));
514Vector128<byte> charMapUpper = Vector128.LoadUnsafe(ref Unsafe.As<ProbabilisticMap, byte>(ref state.Map), (nuint)Vector128<byte>.Count);
523ref char lastStartVectorAvx2 = ref Unsafe.Subtract(ref searchSpaceEnd, 32);
537cur = ref Unsafe.Add(ref cur, 32);
539if (Unsafe.IsAddressGreaterThan(ref cur, ref lastStartVectorAvx2))
541if (Unsafe.AreSame(ref cur, ref searchSpaceEnd))
546if (Unsafe.ByteOffset(ref cur, ref searchSpaceEnd) > 16 * sizeof(char))
556cur = ref Unsafe.Subtract(ref searchSpaceEnd, 16);
563ref char lastStartVector = ref Unsafe.Subtract(ref searchSpaceEnd, 16);
577cur = ref Unsafe.Add(ref cur, 16);
579if (Unsafe.IsAddressGreaterThan(ref cur, ref lastStartVector))
581if (Unsafe.AreSame(ref cur, ref searchSpaceEnd))
601ref char cur = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
603Vector256<byte> charMap256 = Vector256.LoadUnsafe(ref Unsafe.As<ProbabilisticMap, byte>(ref state.Map));
611ref char lastStartVector = ref Unsafe.Add(ref searchSpace, 64);
615Debug.Assert(Unsafe.ByteOffset(ref searchSpace, ref cur) >= 64 * sizeof(char));
617cur = ref Unsafe.Subtract(ref cur, 64);
619Vector512<byte> result = ContainsMask64CharsAvx512(charMap512, ref cur, ref Unsafe.Add(ref cur, Vector512<ushort>.Count));
629if (Unsafe.IsAddressLessThanOrEqualTo(ref cur, ref lastStartVector))
631if (Unsafe.AreSame(ref cur, ref searchSpace))
644Debug.Assert(Unsafe.ByteOffset(ref searchSpace, ref cur) >= 32 * sizeof(char));
648Vector512<byte> result = ContainsMask64CharsAvx512(charMap512, ref searchSpace, ref Unsafe.Subtract(ref cur, Vector512<ushort>.Count));
662Debug.Assert(Unsafe.ByteOffset(ref searchSpace, ref cur) >= 16 * sizeof(char));
666Vector256<byte> result = ContainsMask32CharsAvx512(charMap256, ref searchSpace, ref Unsafe.Subtract(ref cur, Vector256<ushort>.Count));
688ref char cur = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
690Vector128<byte> charMapLower = Vector128.LoadUnsafe(ref Unsafe.As<ProbabilisticMap, byte>(ref state.Map));
691Vector128<byte> charMapUpper = Vector128.LoadUnsafe(ref Unsafe.As<ProbabilisticMap, byte>(ref state.Map), (nuint)Vector128<byte>.Count);
700ref char lastStartVectorAvx2 = ref Unsafe.Add(ref searchSpace, 32);
704Debug.Assert(Unsafe.ByteOffset(ref searchSpace, ref cur) >= 32 * sizeof(char));
706cur = ref Unsafe.Subtract(ref cur, 32);
718if (Unsafe.IsAddressLessThanOrEqualTo(ref cur, ref lastStartVectorAvx2))
720if (Unsafe.AreSame(ref cur, ref searchSpace))
725if (Unsafe.ByteOffset(ref searchSpace, ref cur) > 16 * sizeof(char))
735cur = ref Unsafe.Add(ref searchSpace, 16);
742ref char lastStartVector = ref Unsafe.Add(ref searchSpace, 16);
746Debug.Assert(Unsafe.ByteOffset(ref searchSpace, ref cur) >= 16 * sizeof(char));
748cur = ref Unsafe.Subtract(ref cur, 16);
760if (Unsafe.IsAddressLessThanOrEqualTo(ref cur, ref lastStartVector))
762if (Unsafe.AreSame(ref cur, ref searchSpace))
777(int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref cur) / sizeof(char));
787if (state.ConfirmProbabilisticMatch<TUseFastContains>(Unsafe.Add(ref cur, index)))
815if (state.ConfirmProbabilisticMatch<TUseFastContains>(Unsafe.Add(ref cur, index)))
836if (state.ConfirmProbabilisticMatch<TUseFastContains>(Unsafe.Add(ref cur, index)))
864if (state.ConfirmProbabilisticMatch<TUseFastContains>(Unsafe.Add(ref cur, index)))
885if (state.ConfirmProbabilisticMatch<TUseFastContains>(Unsafe.Add(ref cur, index)))
917if (state.ConfirmProbabilisticMatch<TUseFastContains>(Unsafe.Add(ref cur, index)))
936if (state.ConfirmProbabilisticMatch<TUseFastContains>(Unsafe.Add(ref cur, index)))
968if (state.ConfirmProbabilisticMatch<TUseFastContains>(Unsafe.Add(ref cur, index)))
983ref char searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
986while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd))
994cur = ref Unsafe.Add(ref cur, 1);
1006char c = Unsafe.Add(ref searchSpace, i);
src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticMapState.cs (11)
88return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(hashEntries), (nuint)offset) == value;
98ref Unsafe.As<ProbabilisticMap, uint>(ref Map),
234ref char searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
244while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd))
249return (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref cur) / sizeof(char));
252cur = ref Unsafe.Add(ref cur, 1);
257while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd))
262return (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref cur) / sizeof(char));
265cur = ref Unsafe.Add(ref cur, 1);
286char c = Unsafe.Add(ref searchSpace, searchSpaceLength);
297char c = Unsafe.Add(ref searchSpace, searchSpaceLength);
src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticWithAsciiCharSearchValues.cs (6)
60ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)),
70ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)),
109ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)),
159ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)),
169ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)),
198ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)),
src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\AsciiStringSearchValuesTeddyBase.cs (48)
203ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationVector128);
205searchSpace = ref Unsafe.Add(ref searchSpace, MatchStartOffsetN2);
223searchSpace = ref Unsafe.Add(ref searchSpace, CharsPerIterationVector128);
225if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpaceStart))
227if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpaceStart, CharsPerIterationVector128)))
255ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationAvx2);
257searchSpace = ref Unsafe.Add(ref searchSpace, MatchStartOffsetN2);
275searchSpace = ref Unsafe.Add(ref searchSpace, CharsPerIterationAvx2);
277if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpaceStart))
279if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpaceStart, CharsPerIterationAvx2)))
307ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationAvx512);
309searchSpace = ref Unsafe.Add(ref searchSpace, MatchStartOffsetN2);
327searchSpace = ref Unsafe.Add(ref searchSpace, CharsPerIterationAvx512);
329if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpaceStart))
331if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpaceStart, CharsPerIterationAvx512)))
362ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationVector128);
364searchSpace = ref Unsafe.Add(ref searchSpace, MatchStartOffsetN3);
397searchSpace = ref Unsafe.Add(ref searchSpace, CharsPerIterationVector128);
399if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpaceStart))
401if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpaceStart, CharsPerIterationVector128)))
432ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationAvx2);
434searchSpace = ref Unsafe.Add(ref searchSpace, MatchStartOffsetN3);
454searchSpace = ref Unsafe.Add(ref searchSpace, CharsPerIterationAvx2);
456if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpaceStart))
458if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpaceStart, CharsPerIterationAvx2)))
487ref char lastSearchSpaceStart = ref Unsafe.Add(ref searchSpace, span.Length - CharsPerIterationAvx512);
489searchSpace = ref Unsafe.Add(ref searchSpace, MatchStartOffsetN3);
509searchSpace = ref Unsafe.Add(ref searchSpace, CharsPerIterationAvx512);
511if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpaceStart))
513if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpaceStart, CharsPerIterationAvx512)))
546ref char matchRef = ref Unsafe.Add(ref searchSpace, matchOffset - matchStartOffset);
547offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref matchRef) / 2);
564? StartsWith<TCaseSensitivity>(ref matchRef, lengthRemaining, Unsafe.As<string[]>(bucket))
565: StartsWith<TCaseSensitivity>(ref matchRef, lengthRemaining, Unsafe.As<string>(bucket)))
593ref char matchRef = ref Unsafe.Add(ref searchSpace, matchOffset - matchStartOffset);
594offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref matchRef) / 2);
609? StartsWith<TCaseSensitivity>(ref matchRef, lengthRemaining, Unsafe.As<string[]>(bucket))
610: StartsWith<TCaseSensitivity>(ref matchRef, lengthRemaining, Unsafe.As<string>(bucket)))
638ref char matchRef = ref Unsafe.Add(ref searchSpace, matchOffset - matchStartOffset);
639offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref matchRef) / 2);
654? StartsWith<TCaseSensitivity>(ref matchRef, lengthRemaining, Unsafe.As<string[]>(bucket))
655: StartsWith<TCaseSensitivity>(ref matchRef, lengthRemaining, Unsafe.As<string>(bucket)))
src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\AhoCorasick.cs (13)
100ref Unsafe.As<char, short>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i)),
102ref Unsafe.AsRef(in _startingAsciiChars));
123char c = TCaseSensitivity.TransformInput(Unsafe.Add(ref MemoryMarshal.GetReference(span), i));
128ref AhoCorasickNode node = ref Unsafe.Add(ref nodes, (uint)nodeIndex);
136int matchLength = Unsafe.Add(ref nodes, (uint)nodeIndex).MatchLength;
209ref Unsafe.As<char, short>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i)),
211ref Unsafe.AsRef(in _startingAsciiChars));
242c = Unsafe.Add(ref MemoryMarshal.GetReference(span), i);
247char.IsLowSurrogate(lowSurrogate = Unsafe.Add(ref MemoryMarshal.GetReference(span), i + 1)))
277ref AhoCorasickNode node = ref Unsafe.Add(ref nodes, (uint)nodeIndex);
285int matchLength = Unsafe.Add(ref nodes, (uint)nodeIndex).MatchLength;
src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\StringSearchValuesHelper.cs (41)
31nint currentByteOffset = Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref searchSpace);
76ref Unsafe.As<char, byte>(ref matchStart),
151Vector128.LoadUnsafe(ref Unsafe.AddByteOffset(ref value.GetRawStringDataAsUInt16(), SecondReadByteOffset)));
157Unsafe.ReadUnaligned<ulong>(ref value.GetRawStringDataAsUInt8()),
158Unsafe.ReadUnaligned<ulong>(ref Unsafe.Add(ref value.GetRawStringDataAsUInt8(), SecondReadByteOffset))
167Unsafe.ReadUnaligned<uint>(ref value.GetRawStringDataAsUInt8()),
168Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref value.GetRawStringDataAsUInt8(), SecondReadByteOffset))
193Vector128.LoadUnsafe(ref Unsafe.AddByteOffset(ref matchStart, SecondReadByteOffset)));
200different |= Vector128.LoadUnsafe(ref Unsafe.AddByteOffset(ref matchStart, SecondReadByteOffset)) ^ Value256.GetUpper();
215Vector128.LoadUnsafe(ref Unsafe.AddByteOffset(ref matchStart, SecondReadByteOffset)));
222different |= (Vector128.LoadUnsafe(ref Unsafe.AddByteOffset(ref matchStart, SecondReadByteOffset)) & ToUpperMask256.GetUpper()) ^ Value256.GetUpper();
266ref byte matchByteStart = ref Unsafe.As<char, byte>(ref matchStart);
267ulong differentBits = Unsafe.ReadUnaligned<ulong>(ref matchByteStart) - state.Value64_0;
268differentBits |= Unsafe.ReadUnaligned<ulong>(ref Unsafe.Add(ref matchByteStart, state.SecondReadByteOffset)) - state.Value64_1;
275ref byte matchByteStart = ref Unsafe.As<char, byte>(ref matchStart);
285uint differentBits = Unsafe.ReadUnaligned<uint>(ref matchByteStart) - state.Value32_0;
286differentBits |= Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref matchByteStart, state.SecondReadByteOffset)) - state.Value32_1;
297return Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref matchByteStart, state.SecondReadByteOffset)) == state.Value32_1;
334ref byte matchByteStart = ref Unsafe.As<char, byte>(ref matchStart);
335ulong differentBits = (Unsafe.ReadUnaligned<ulong>(ref matchByteStart) & CaseMask) - state.Value64_0;
336differentBits |= (Unsafe.ReadUnaligned<ulong>(ref Unsafe.Add(ref matchByteStart, state.SecondReadByteOffset)) & CaseMask) - state.Value64_1;
344ref byte matchByteStart = ref Unsafe.As<char, byte>(ref matchStart);
354uint differentBits = (Unsafe.ReadUnaligned<uint>(ref matchByteStart) & CaseMask) - state.Value32_0;
355differentBits |= (Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref matchByteStart, state.SecondReadByteOffset)) & CaseMask) - state.Value32_1;
366return (Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref matchByteStart, state.SecondReadByteOffset)) & CaseMask) == state.Value32_1;
426ref byte matchByteStart = ref Unsafe.As<char, byte>(ref matchStart);
427ulong differentBits = (Unsafe.ReadUnaligned<ulong>(ref matchByteStart) & state.ToUpperMask64_0) - state.Value64_0;
428differentBits |= (Unsafe.ReadUnaligned<ulong>(ref Unsafe.Add(ref matchByteStart, state.SecondReadByteOffset)) & state.ToUpperMask64_1) - state.Value64_1;
435ref byte matchByteStart = ref Unsafe.As<char, byte>(ref matchStart);
436uint differentBits = (Unsafe.ReadUnaligned<uint>(ref matchByteStart) & state.ToUpperMask32_0) - state.Value32_0;
437differentBits |= (Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref matchByteStart, state.SecondReadByteOffset)) & state.ToUpperMask32_1) - state.Value32_1;
src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesPackedThreeChars.cs (26)
96ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector512<byte>.Count);
114searchSpace = ref Unsafe.Add(ref searchSpace, Vector512<byte>.Count);
116if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpace))
118if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector512<byte>.Count)))
144ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector256<byte>.Count);
161searchSpace = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count);
163if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpace))
165if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector256<byte>.Count)))
191ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector128<byte>.Count);
208searchSpace = ref Unsafe.Add(ref searchSpace, Vector128<byte>.Count);
210if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpace))
212if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector128<byte>.Count)))
237ref char cur = ref Unsafe.Add(ref searchSpace, i);
337ref char matchRef = ref Unsafe.Add(ref searchSpace, bitPos);
343offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref searchSpaceStart, ref matchRef) / sizeof(char));
364ref char matchRef = ref Unsafe.Add(ref searchSpace, bitPos);
370offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref searchSpaceStart, ref matchRef) / sizeof(char));
395Vector128<ushort> input0 = Vector128.LoadUnsafe(ref Unsafe.AddByteOffset(ref searchSpace, byteOffset));
396Vector128<ushort> input1 = Vector128.LoadUnsafe(ref Unsafe.AddByteOffset(ref searchSpace, byteOffset + (uint)Vector128<byte>.Count));
407Vector256.LoadUnsafe(ref Unsafe.AddByteOffset(ref searchSpace, byteOffset)).AsInt16(),
408Vector256.LoadUnsafe(ref Unsafe.AddByteOffset(ref searchSpace, byteOffset + (uint)Vector256<byte>.Count)).AsInt16());
414Vector512.LoadUnsafe(ref Unsafe.AddByteOffset(ref searchSpace, byteOffset)).AsInt16(),
415Vector512.LoadUnsafe(ref Unsafe.AddByteOffset(ref searchSpace, byteOffset + (uint)Vector512<byte>.Count)).AsInt16());
src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesThreeChars.cs (32)
96ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector512<ushort>.Count);
114searchSpace = ref Unsafe.Add(ref searchSpace, Vector512<ushort>.Count);
116if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpace))
118if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector512<ushort>.Count)))
144ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector256<ushort>.Count);
161searchSpace = ref Unsafe.Add(ref searchSpace, Vector256<ushort>.Count);
163if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpace))
165if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector256<ushort>.Count)))
191ref char lastSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceMinusValueTailLength - Vector128<ushort>.Count);
208searchSpace = ref Unsafe.Add(ref searchSpace, Vector128<ushort>.Count);
210if (Unsafe.IsAddressGreaterThan(ref searchSpace, ref lastSearchSpace))
212if (Unsafe.AreSame(ref searchSpace, ref Unsafe.Add(ref lastSearchSpace, Vector128<ushort>.Count)))
238ref char cur = ref Unsafe.Add(ref searchSpace, i);
259Vector128<ushort> cmpCh2 = Vector128.Equals(ch2, Vector128.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16());
260Vector128<ushort> cmpCh3 = Vector128.Equals(ch3, Vector128.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16());
272Vector128<ushort> cmpCh2 = Vector128.Equals(ch2, Vector128.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16() & caseConversion);
273Vector128<ushort> cmpCh3 = Vector128.Equals(ch3, Vector128.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16() & caseConversion);
287Vector256<ushort> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16());
288Vector256<ushort> cmpCh3 = Vector256.Equals(ch3, Vector256.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16());
296Vector256<ushort> cmpCh2 = Vector256.Equals(ch2, Vector256.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16() & caseConversion);
297Vector256<ushort> cmpCh3 = Vector256.Equals(ch3, Vector256.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16() & caseConversion);
310Vector512<ushort> cmpCh2 = Vector512.Equals(ch2, Vector512.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16());
311Vector512<ushort> cmpCh3 = Vector512.Equals(ch3, Vector512.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16());
319Vector512<ushort> cmpCh2 = Vector512.Equals(ch2, Vector512.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch2ByteOffset).AsUInt16() & caseConversion);
320Vector512<ushort> cmpCh3 = Vector512.Equals(ch3, Vector512.LoadUnsafe(ref Unsafe.As<char, byte>(ref searchSpace), ch3ByteOffset).AsUInt16() & caseConversion);
335ref char matchRef = ref Unsafe.AddByteOffset(ref searchSpace, bitPos);
341offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref searchSpaceStart, ref matchRef) / sizeof(char));
363ref char matchRef = ref Unsafe.AddByteOffset(ref searchSpace, bitPos);
369offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref searchSpaceStart, ref matchRef) / 2);
src\libraries\System.Private.CoreLib\src\System\Span.cs (9)
88_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */);
155return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */);
285ref T ret = ref Unsafe.NullRef<T>();
298SpanHelpers.ClearWithReferences(ref Unsafe.As<T, IntPtr>(ref _reference), (uint)_length * (nuint)(sizeof(T) / sizeof(nuint)));
302SpanHelpers.ClearWithoutReferences(ref Unsafe.As<T, byte>(ref _reference), (uint)_length * (nuint)sizeof(T));
366Unsafe.AreSame(ref left._reference, ref right._reference);
382return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length));
400return new Span<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start);
428return new Span<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), length);
src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Byte.cs (75)
36ref byte valueTail = ref Unsafe.Add(ref value, 1);
42int relativeIndex = IndexOfValueType(ref Unsafe.Add(ref searchSpace, offset), valueHead, remainingSearchSpaceLength);
54ref Unsafe.Add(ref searchSpace, offset + 1),
70byte ch2Val = Unsafe.Add(ref value, valueTailLength);
73ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
116ref Unsafe.Add(ref searchSpace, offset + bitPos),
131byte ch2Val = Unsafe.Add(ref value, valueTailLength);
134ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
177ref Unsafe.Add(ref searchSpace, offset + bitPos),
192byte ch2Val = Unsafe.Add(ref value, valueTailLength);
195ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
238ref Unsafe.Add(ref searchSpace, offset + bitPos),
272ref byte valueTail = ref Unsafe.Add(ref value, 1);
288ref Unsafe.Add(ref searchSpace, relativeIndex + 1),
305byte ch2Val = Unsafe.Add(ref value, valueTailLength);
308ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
328ref Unsafe.Add(ref searchSpace, offset + highestSetBitIndex),
352byte ch2Val = Unsafe.Add(ref value, valueTailLength);
355ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
375ref Unsafe.Add(ref searchSpace, offset + highestSetBitIndex),
399byte ch2Val = Unsafe.Add(ref value, valueTailLength);
402ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
424ref Unsafe.Add(ref searchSpace, offset + highestSetBitIndex),
786differentBits |= (uint)Unsafe.AddByteOffset(ref first, offset) - (uint)Unsafe.AddByteOffset(ref second, offset);
804if (!Unsafe.AreSame(ref first, ref second))
968if (Unsafe.AreSame(ref first, ref second))
1013int result = Unsafe.AddByteOffset(ref first, offset).CompareTo(Unsafe.AddByteOffset(ref second, offset));
1054int result = Unsafe.AddByteOffset(ref first, offset).CompareTo(Unsafe.AddByteOffset(ref second, offset));
1091int result = Unsafe.AddByteOffset(ref first, offset).CompareTo(Unsafe.AddByteOffset(ref second, offset));
1140int result = Unsafe.AddByteOffset(ref first, offset).CompareTo(Unsafe.AddByteOffset(ref second, offset));
1171if (Unsafe.Add(ref first, 1) != Unsafe.Add(ref second, 1))
1176if (i > 2 && Unsafe.Add(ref first, 2) != Unsafe.Add(ref second, 2))
1185if (Unsafe.Add(ref first, i + 0) != Unsafe.Add(ref second, i + 0)) goto Found0;
1186if (Unsafe.Add(ref first, i + 1) != Unsafe.Add(ref second, i + 1)) goto Found1;
1187if (Unsafe.Add(ref first, i + 2) != Unsafe.Add(ref second, i + 2)) goto Found2;
1188if (Unsafe.Add(ref first, i + 3) != Unsafe.Add(ref second, i + 3)) goto Found3;
1254=> Unsafe.ReadUnaligned<ushort>(ref start);
1258=> Unsafe.ReadUnaligned<uint>(ref start);
1262=> Unsafe.ReadUnaligned<uint>(ref Unsafe.AddByteOffset(ref start, offset));
1266=> Unsafe.ReadUnaligned<nuint>(ref start);
1270=> Unsafe.ReadUnaligned<nuint>(ref Unsafe.AddByteOffset(ref start, offset));
1274=> Unsafe.ReadUnaligned<Vector128<byte>>(ref Unsafe.AddByteOffset(ref start, offset));
1278=> Unsafe.ReadUnaligned<Vector256<byte>>(ref Unsafe.AddByteOffset(ref start, offset));
1429long tempFirst = Unsafe.ReadUnaligned<long>(ref Unsafe.Add(ref buf, offset));
1430long tempLast = Unsafe.ReadUnaligned<long>(ref Unsafe.Add(ref buf, lastOffset));
1433Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, offset), BinaryPrimitives.ReverseEndianness(tempLast));
1434Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, lastOffset), BinaryPrimitives.ReverseEndianness(tempFirst));
1448int tempFirst = Unsafe.ReadUnaligned<int>(ref Unsafe.Add(ref buf, offset));
1449int tempLast = Unsafe.ReadUnaligned<int>(ref Unsafe.Add(ref buf, lastOffset));
1452Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, offset), BinaryPrimitives.ReverseEndianness(tempLast));
1453Unsafe.WriteUnaligned(ref Unsafe.Add(ref buf, lastOffset), BinaryPrimitives.ReverseEndianness(tempFirst));
1464ReverseInner(ref Unsafe.Add(ref buf, offset), (nuint)remainder);
src\libraries\System.Private.CoreLib\src\System\SpanHelpers.ByteMemOps.cs (100)
40if ((nuint)Unsafe.ByteOffset(ref src, ref dest) < len ||
41(nuint)Unsafe.ByteOffset(ref dest, ref src) < len)
46ref byte srcEnd = ref Unsafe.Add(ref src, len);
47ref byte destEnd = ref Unsafe.Add(ref dest, len);
58Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<Block16>(ref src));
71Unsafe.WriteUnaligned(ref Unsafe.Add(ref dest, 16), Unsafe.ReadUnaligned<Block16>(ref Unsafe.Add(ref src, 16)));
84Unsafe.WriteUnaligned(ref Unsafe.Add(ref dest, 32), Unsafe.ReadUnaligned<Block16>(ref Unsafe.Add(ref src, 32)));
99Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -16), Unsafe.ReadUnaligned<Block16>(ref Unsafe.Add(ref srcEnd, -16)));
117Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<long>(ref src));
118Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -8), Unsafe.ReadUnaligned<long>(ref Unsafe.Add(ref srcEnd, -8)));
132Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<int>(ref src));
133Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -4), Unsafe.ReadUnaligned<int>(ref Unsafe.Add(ref srcEnd, -4)));
144Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -2), Unsafe.ReadUnaligned<short>(ref Unsafe.Add(ref srcEnd, -2)));
162nuint misalignedElements = 64 - Unsafe.OpportunisticMisalignment(ref dest, 64);
163Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<Block64>(ref src));
164src = ref Unsafe.Add(ref src, misalignedElements);
165dest = ref Unsafe.Add(ref dest, misalignedElements);
177Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<Block64>(ref src));
205dest = ref Unsafe.Add(ref dest, 64);
206src = ref Unsafe.Add(ref src, 64);
215Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -16), Unsafe.ReadUnaligned<Block16>(ref Unsafe.Add(ref srcEnd, -16)));
230if (Unsafe.AreSame(ref dest, ref src))
233_ = Unsafe.ReadUnaligned<byte>(ref dest);
240_ = Unsafe.ReadUnaligned<byte>(ref dest);
241_ = Unsafe.ReadUnaligned<byte>(ref src);
274ref byte destEnd = ref Unsafe.Add(ref dest, len);
285Unsafe.WriteUnaligned<Block16>(ref dest, default);
298Unsafe.WriteUnaligned<Block16>(ref Unsafe.Add(ref dest, 16), default);
311Unsafe.WriteUnaligned<Block16>(ref Unsafe.Add(ref dest, 32), default);
326Unsafe.WriteUnaligned<Block16>(ref Unsafe.Add(ref destEnd, -16), default);
344Unsafe.WriteUnaligned<long>(ref dest, 0);
345Unsafe.WriteUnaligned<long>(ref Unsafe.Add(ref destEnd, -8), 0);
359Unsafe.WriteUnaligned<int>(ref dest, 0);
360Unsafe.WriteUnaligned<int>(ref Unsafe.Add(ref destEnd, -4), 0);
371Unsafe.WriteUnaligned<short>(ref Unsafe.Add(ref destEnd, -2), 0);
386nuint misalignedElements = 64 - Unsafe.OpportunisticMisalignment(ref dest, 64);
387Unsafe.WriteUnaligned<Block64>(ref dest, default);
388dest = ref Unsafe.Add(ref dest, misalignedElements);
399Unsafe.WriteUnaligned<Block64>(ref dest, default);
427dest = ref Unsafe.Add(ref dest, 64);
436Unsafe.WriteUnaligned<Block16>(ref Unsafe.Add(ref destEnd, -16), default);
450_ = Unsafe.ReadUnaligned<byte>(ref dest);
467Unsafe.WriteUnaligned<Block16>(ptr, default);
468Unsafe.WriteUnaligned<Block16>(ptr + byteLength - 16, default);
512Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref dest, offset), vector);
513Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref dest, offset + (nuint)Vector<byte>.Count), vector);
525Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref dest, offset), vector);
534Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref dest, len - (nuint)Vector<byte>.Count), vector);
552Unsafe.Add(ref dest, (nint)i + 0) = value;
553Unsafe.Add(ref dest, (nint)i + 1) = value;
554Unsafe.Add(ref dest, (nint)i + 2) = value;
555Unsafe.Add(ref dest, (nint)i + 3) = value;
556Unsafe.Add(ref dest, (nint)i + 4) = value;
557Unsafe.Add(ref dest, (nint)i + 5) = value;
558Unsafe.Add(ref dest, (nint)i + 6) = value;
559Unsafe.Add(ref dest, (nint)i + 7) = value;
566Unsafe.Add(ref dest, (nint)i + 0) = value;
567Unsafe.Add(ref dest, (nint)i + 1) = value;
568Unsafe.Add(ref dest, (nint)i + 2) = value;
569Unsafe.Add(ref dest, (nint)i + 3) = value;
576Unsafe.Add(ref dest, (nint)i + 0) = value;
577Unsafe.Add(ref dest, (nint)i + 1) = value;
584Unsafe.Add(ref dest, (nint)i) = value;
src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Char.cs (75)
37ref byte valueTail = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref value, 1));
44int relativeIndex = NonPackedIndexOfChar(ref Unsafe.Add(ref searchSpace, offset), valueHead, remainingSearchSpaceLength);
56ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + 1)),
75ushort ch2Val = Unsafe.Add(ref value, valueTailLength);
78ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
122ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
123ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
142ushort ch2Val = Unsafe.Add(ref value, valueTailLength);
145ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
187ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
188ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
204ushort ch2Val = Unsafe.Add(ref value, valueTailLength);
207ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
249ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
250ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
274return LastIndexOfValueType(ref Unsafe.As<char, short>(ref searchSpace), (short)value, searchSpaceLength); // for single-char values use plain LastIndexOf
284ref byte valueTail = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref value, 1));
294int relativeIndex = LastIndexOfValueType(ref Unsafe.As<char, short>(ref searchSpace), (short)valueHead, remainingSearchSpaceLength);
300ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, relativeIndex + 1)),
319char ch2Val = Unsafe.Add(ref value, valueTailLength);
322ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
346ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
347ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
369char ch2Val = Unsafe.Add(ref value, valueTailLength);
372ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
396ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
397ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
419char ch2Val = Unsafe.Add(ref value, valueTailLength);
422ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
446ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
447ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
472if (Unsafe.AreSame(ref first, ref second))
485if (Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, (nint)i))) !=
486Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, (nint)i))))
497if (Unsafe.ReadUnaligned<nuint>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, (nint)i))) !=
498Unsafe.ReadUnaligned<nuint>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, (nint)i))))
509if (Unsafe.ReadUnaligned<int>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, (nint)i))) ==
510Unsafe.ReadUnaligned<int>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, (nint)i))))
519int result = Unsafe.Add(ref first, (nint)i).CompareTo(Unsafe.Add(ref second, (nint)i));
899ref ushort first = ref Unsafe.As<char, ushort>(ref Unsafe.Add(ref buf, offset));
900ref ushort last = ref Unsafe.As<char, ushort>(ref Unsafe.Add(ref buf, lastOffset));
938ref byte first = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref buf, offset));
939ref byte last = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref buf, lastOffset));
977ref ushort first = ref Unsafe.As<char, ushort>(ref Unsafe.Add(ref buf, offset));
978ref ushort last = ref Unsafe.As<char, ushort>(ref Unsafe.Add(ref buf, lastOffset));
1008ReverseInner(ref Unsafe.Add(ref buf, offset), (nuint)remainder);
src\libraries\System.Private.CoreLib\src\System\SpanHelpers.cs (37)
15Debug.Assert(Unsafe.IsOpportunisticallyAligned(ref ip, (uint)sizeof(IntPtr)), "Should've been aligned on natural word boundary.");
23Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -1) = default;
24Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -2) = default;
25Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -3) = default;
26Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -4) = default;
27Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -5) = default;
28Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -6) = default;
29Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -7) = default;
30Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -8) = default;
69Unsafe.Add(ref ip, 2) = default;
70Unsafe.Add(ref ip, 3) = default;
71Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -3) = default;
72Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -2) = default;
78Unsafe.Add(ref ip, 1) = default;
79Unsafe.Add(ref Unsafe.Add(ref ip, (nint)pointerSizeLength), -1) = default;
189ReverseInner(ref Unsafe.Add(ref buf, offset), (nuint)remainder);
294ReverseInner(ref Unsafe.Add(ref buf, offset), (nuint)remainder);
307Reverse(ref Unsafe.As<T, byte>(ref elements), length);
312Reverse(ref Unsafe.As<T, char>(ref elements), length);
317Reverse(ref Unsafe.As<T, int>(ref elements), length);
322Reverse(ref Unsafe.As<T, long>(ref elements), length);
336ref T last = ref Unsafe.Subtract(ref Unsafe.Add(ref first, length), 1);
342first = ref Unsafe.Add(ref first, 1);
343last = ref Unsafe.Subtract(ref last, 1);
344} while (Unsafe.IsAddressLessThan(ref first, ref last));
src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Packed.cs (111)
28return Unsafe.BitCast<T, ushort>(value) - 1u < 254u;
34IndexOf<SpanHelpers.DontNegate<short>, NopTransform>(ref Unsafe.As<char, short>(ref searchSpace), (short)value, length);
39IndexOf<SpanHelpers.Negate<short>, NopTransform>(ref Unsafe.As<char, short>(ref searchSpace), (short)value, length);
44IndexOfAny<SpanHelpers.DontNegate<short>, NopTransform>(ref Unsafe.As<char, short>(ref searchSpace), (short)value0, (short)value1, length);
49IndexOfAny<SpanHelpers.Negate<short>, NopTransform>(ref Unsafe.As<char, short>(ref searchSpace), (short)value0, (short)value1, length);
54IndexOfAny<SpanHelpers.DontNegate<short>>(ref Unsafe.As<char, short>(ref searchSpace), (short)value0, (short)value1, (short)value2, length);
59IndexOfAny<SpanHelpers.Negate<short>>(ref Unsafe.As<char, short>(ref searchSpace), (short)value0, (short)value1, (short)value2, length);
67return IndexOf<SpanHelpers.DontNegate<short>, Or20Transform>(ref Unsafe.As<char, short>(ref searchSpace), (short)value, length);
76return IndexOf<SpanHelpers.Negate<short>, Or20Transform>(ref Unsafe.As<char, short>(ref searchSpace), (short)value, length);
86return IndexOfAny<SpanHelpers.DontNegate<short>, Or20Transform>(ref Unsafe.As<char, short>(ref searchSpace), (short)value0, (short)value1, length);
96return IndexOfAny<SpanHelpers.Negate<short>, Or20Transform>(ref Unsafe.As<char, short>(ref searchSpace), (short)value0, (short)value1, length);
102IndexOfAnyInRange<SpanHelpers.DontNegate<short>>(ref Unsafe.As<char, short>(ref searchSpace), (short)lowInclusive, (short)rangeInclusive, length);
107IndexOfAnyInRange<SpanHelpers.Negate<short>>(ref Unsafe.As<char, short>(ref searchSpace), (short)lowInclusive, (short)rangeInclusive, length);
123Unsafe.Add(ref searchSpace, 1) == value ||
124Unsafe.Add(ref searchSpace, 2) == value ||
125Unsafe.Add(ref searchSpace, 3) == value)
137if (Unsafe.Add(ref searchSpace, offset) == value)
160ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector512<short>.Count));
173currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector512<short>.Count);
175while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
181ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector512<short>.Count);
183ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
209ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count));
223currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count);
225while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
231ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count);
233ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
267ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector128<short>.Count));
281currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector128<short>.Count);
283while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
289ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector128<short>.Count);
291ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
327if (TNegator.NegateIfNeeded(TTransform.TransformInput(Unsafe.Add(ref searchSpace, 1)) == value)) return 1;
328if (TNegator.NegateIfNeeded(TTransform.TransformInput(Unsafe.Add(ref searchSpace, 2)) == value)) return 2;
329if (TNegator.NegateIfNeeded(TTransform.TransformInput(Unsafe.Add(ref searchSpace, 3)) == value)) return 3;
338if (TNegator.NegateIfNeeded(TTransform.TransformInput(Unsafe.Add(ref searchSpace, offset)) == value)) return (int)offset;
359ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector512<short>.Count));
372currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector512<short>.Count);
374while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
380ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector512<short>.Count);
382ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
408ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count));
423currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count);
425while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
431ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count);
433ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
468ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector128<short>.Count));
483currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector128<short>.Count);
485while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
491ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector128<short>.Count);
493ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
533lookUp = TTransform.TransformInput(Unsafe.Add(ref searchSpace, 1));
535lookUp = TTransform.TransformInput(Unsafe.Add(ref searchSpace, 2));
537lookUp = TTransform.TransformInput(Unsafe.Add(ref searchSpace, 3));
547lookUp = TTransform.TransformInput(Unsafe.Add(ref searchSpace, offset));
569ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector512<short>.Count));
583currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector512<short>.Count);
585while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
591ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector512<short>.Count);
593ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
621ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count));
636currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count);
638while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
644ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count);
646ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
682ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector128<short>.Count));
697currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector128<short>.Count);
699while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
705ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector128<short>.Count);
707ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
747lookUp = Unsafe.Add(ref searchSpace, 1);
749lookUp = Unsafe.Add(ref searchSpace, 2);
751lookUp = Unsafe.Add(ref searchSpace, 3);
761lookUp = Unsafe.Add(ref searchSpace, offset);
785ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector512<short>.Count));
799currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector512<short>.Count);
801while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
807ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector512<short>.Count);
809ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
838ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count));
853currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count);
855while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
861ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count);
863ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
900ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector128<short>.Count));
915currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector128<short>.Count);
917while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
923ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector128<short>.Count);
925ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
960uint current = (uint)Unsafe.Add(ref searchSpace, i);
984ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector512<short>.Count));
997currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector512<short>.Count);
999while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
1005ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector512<short>.Count);
1007ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
1034ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector256<short>.Count));
1049currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count);
1051while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
1057ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<short>.Count);
1059ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
1095ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - (2 * Vector128<short>.Count));
1110currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector128<short>.Count);
1112while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
1118ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector128<short>.Count);
1120ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
1234return index + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / sizeof(short));
1243return index + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / sizeof(short));
1252return index + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / sizeof(short));
1266return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current0) / sizeof(short));
1281return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current0) / sizeof(short));
1296return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current0) / sizeof(short));
src\libraries\System.Private.CoreLib\src\System\SpanHelpers.T.cs (421)
50vector = new Vector<byte>(Unsafe.BitCast<T, byte>(value));
54vector = (Vector<byte>)new Vector<ushort>(Unsafe.BitCast<T, ushort>(value));
60? (Vector<byte>)new Vector<float>(Unsafe.BitCast<T, float>(value))
61: (Vector<byte>)new Vector<uint>(Unsafe.BitCast<T, uint>(value));
67? (Vector<byte>)new Vector<double>(Unsafe.BitCast<T, double>(value))
68: (Vector<byte>)new Vector<ulong>(Unsafe.BitCast<T, ulong>(value));
72vector = Unsafe.BitCast<T, Vector<byte>>(value);
78vector = Vector256.Create(Unsafe.BitCast<T, Vector128<byte>>(value)).AsVector();
82vector = Vector512.Create(Unsafe.BitCast<T, Vector128<byte>>(value)).AsVector();
94vector = Vector512.Create(Unsafe.BitCast<T, Vector256<byte>>(value)).AsVector();
108ref byte refDataAsBytes = ref Unsafe.As<T, byte>(ref refData);
121Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref refDataAsBytes, offset), vector);
122Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref refDataAsBytes, offset + (nuint)Vector<byte>.Count), vector);
135Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref refDataAsBytes, offset), vector);
145Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref refDataAsBytes, totalByteLength - (nuint)Vector<byte>.Count), vector);
166Unsafe.Add(ref refData, (nint)i + 0) = value;
167Unsafe.Add(ref refData, (nint)i + 1) = value;
168Unsafe.Add(ref refData, (nint)i + 2) = value;
169Unsafe.Add(ref refData, (nint)i + 3) = value;
170Unsafe.Add(ref refData, (nint)i + 4) = value;
171Unsafe.Add(ref refData, (nint)i + 5) = value;
172Unsafe.Add(ref refData, (nint)i + 6) = value;
173Unsafe.Add(ref refData, (nint)i + 7) = value;
181Unsafe.Add(ref refData, (nint)i + 0) = value;
182Unsafe.Add(ref refData, (nint)i + 1) = value;
183Unsafe.Add(ref refData, (nint)i + 2) = value;
184Unsafe.Add(ref refData, (nint)i + 3) = value;
192Unsafe.Add(ref refData, (nint)i + 0) = value;
193Unsafe.Add(ref refData, (nint)i + 1) = value;
201Unsafe.Add(ref refData, (nint)i) = value;
214ref T valueTail = ref Unsafe.Add(ref value, 1);
228int relativeIndex = IndexOf(ref Unsafe.Add(ref searchSpace, index), valueHead, remainingSearchSpaceLength);
236if (SequenceEqual(ref Unsafe.Add(ref searchSpace, index + 1), ref valueTail, valueTailLength))
261if (value.Equals(Unsafe.Add(ref searchSpace, index + 0)) ||
262value.Equals(Unsafe.Add(ref searchSpace, index + 1)) ||
263value.Equals(Unsafe.Add(ref searchSpace, index + 2)) ||
264value.Equals(Unsafe.Add(ref searchSpace, index + 3)) ||
265value.Equals(Unsafe.Add(ref searchSpace, index + 4)) ||
266value.Equals(Unsafe.Add(ref searchSpace, index + 5)) ||
267value.Equals(Unsafe.Add(ref searchSpace, index + 6)) ||
268value.Equals(Unsafe.Add(ref searchSpace, index + 7)))
280if (value.Equals(Unsafe.Add(ref searchSpace, index + 0)) ||
281value.Equals(Unsafe.Add(ref searchSpace, index + 1)) ||
282value.Equals(Unsafe.Add(ref searchSpace, index + 2)) ||
283value.Equals(Unsafe.Add(ref searchSpace, index + 3)))
295if (value.Equals(Unsafe.Add(ref searchSpace, index)))
308if ((object?)Unsafe.Add(ref searchSpace, index) is null)
331if (value.Equals(Unsafe.Add(ref searchSpace, index)))
335if (value.Equals(Unsafe.Add(ref searchSpace, index + 1)))
339if (value.Equals(Unsafe.Add(ref searchSpace, index + 2)))
343if (value.Equals(Unsafe.Add(ref searchSpace, index + 3)))
347if (value.Equals(Unsafe.Add(ref searchSpace, index + 4)))
351if (value.Equals(Unsafe.Add(ref searchSpace, index + 5)))
355if (value.Equals(Unsafe.Add(ref searchSpace, index + 6)))
359if (value.Equals(Unsafe.Add(ref searchSpace, index + 7)))
371if (value.Equals(Unsafe.Add(ref searchSpace, index)))
375if (value.Equals(Unsafe.Add(ref searchSpace, index + 1)))
379if (value.Equals(Unsafe.Add(ref searchSpace, index + 2)))
383if (value.Equals(Unsafe.Add(ref searchSpace, index + 3)))
393if (value.Equals(Unsafe.Add(ref searchSpace, index)))
407if ((object?)Unsafe.Add(ref searchSpace, index) is null)
429lookUp = Unsafe.Add(ref searchSpace, index);
435lookUp = Unsafe.Add(ref searchSpace, index + 1);
441lookUp = Unsafe.Add(ref searchSpace, index + 2);
447lookUp = Unsafe.Add(ref searchSpace, index + 3);
453lookUp = Unsafe.Add(ref searchSpace, index + 4);
459lookUp = Unsafe.Add(ref searchSpace, index + 5);
465lookUp = Unsafe.Add(ref searchSpace, index + 6);
471lookUp = Unsafe.Add(ref searchSpace, index + 7);
482lookUp = Unsafe.Add(ref searchSpace, index);
488lookUp = Unsafe.Add(ref searchSpace, index + 1);
494lookUp = Unsafe.Add(ref searchSpace, index + 2);
500lookUp = Unsafe.Add(ref searchSpace, index + 3);
511lookUp = Unsafe.Add(ref searchSpace, index);
524lookUp = Unsafe.Add(ref searchSpace, index);
554lookUp = Unsafe.Add(ref searchSpace, index);
560lookUp = Unsafe.Add(ref searchSpace, index + 1);
566lookUp = Unsafe.Add(ref searchSpace, index + 2);
572lookUp = Unsafe.Add(ref searchSpace, index + 3);
578lookUp = Unsafe.Add(ref searchSpace, index + 4);
584lookUp = Unsafe.Add(ref searchSpace, index + 5);
590lookUp = Unsafe.Add(ref searchSpace, index + 6);
596lookUp = Unsafe.Add(ref searchSpace, index + 7);
607lookUp = Unsafe.Add(ref searchSpace, index);
613lookUp = Unsafe.Add(ref searchSpace, index + 1);
619lookUp = Unsafe.Add(ref searchSpace, index + 2);
625lookUp = Unsafe.Add(ref searchSpace, index + 3);
636lookUp = Unsafe.Add(ref searchSpace, index);
649lookUp = Unsafe.Add(ref searchSpace, index);
693T candidate = Unsafe.Add(ref searchSpace, i);
696if (Unsafe.Add(ref value, j)!.Equals(candidate))
709T candidate = Unsafe.Add(ref searchSpace, i);
714if (candidate.Equals(Unsafe.Add(ref value, j)))
724if (Unsafe.Add(ref value, j) is null)
753ref T valueTail = ref Unsafe.Add(ref value, 1);
772if (SequenceEqual(ref Unsafe.Add(ref searchSpace, relativeIndex + 1), ref valueTail, valueTailLength))
794if (value.Equals(Unsafe.Add(ref searchSpace, length + 7)))
798if (value.Equals(Unsafe.Add(ref searchSpace, length + 6)))
802if (value.Equals(Unsafe.Add(ref searchSpace, length + 5)))
806if (value.Equals(Unsafe.Add(ref searchSpace, length + 4)))
810if (value.Equals(Unsafe.Add(ref searchSpace, length + 3)))
814if (value.Equals(Unsafe.Add(ref searchSpace, length + 2)))
818if (value.Equals(Unsafe.Add(ref searchSpace, length + 1)))
822if (value.Equals(Unsafe.Add(ref searchSpace, length)))
832if (value.Equals(Unsafe.Add(ref searchSpace, length + 3)))
836if (value.Equals(Unsafe.Add(ref searchSpace, length + 2)))
840if (value.Equals(Unsafe.Add(ref searchSpace, length + 1)))
844if (value.Equals(Unsafe.Add(ref searchSpace, length)))
854if (value.Equals(Unsafe.Add(ref searchSpace, length)))
864if ((object?)Unsafe.Add(ref searchSpace, length) is null)
887lookUp = Unsafe.Add(ref searchSpace, length + 7);
893lookUp = Unsafe.Add(ref searchSpace, length + 6);
899lookUp = Unsafe.Add(ref searchSpace, length + 5);
905lookUp = Unsafe.Add(ref searchSpace, length + 4);
911lookUp = Unsafe.Add(ref searchSpace, length + 3);
917lookUp = Unsafe.Add(ref searchSpace, length + 2);
923lookUp = Unsafe.Add(ref searchSpace, length + 1);
929lookUp = Unsafe.Add(ref searchSpace, length);
940lookUp = Unsafe.Add(ref searchSpace, length + 3);
946lookUp = Unsafe.Add(ref searchSpace, length + 2);
952lookUp = Unsafe.Add(ref searchSpace, length + 1);
958lookUp = Unsafe.Add(ref searchSpace, length);
969lookUp = Unsafe.Add(ref searchSpace, length);
980lookUp = Unsafe.Add(ref searchSpace, length);
1011lookUp = Unsafe.Add(ref searchSpace, length + 7);
1017lookUp = Unsafe.Add(ref searchSpace, length + 6);
1023lookUp = Unsafe.Add(ref searchSpace, length + 5);
1029lookUp = Unsafe.Add(ref searchSpace, length + 4);
1035lookUp = Unsafe.Add(ref searchSpace, length + 3);
1041lookUp = Unsafe.Add(ref searchSpace, length + 2);
1047lookUp = Unsafe.Add(ref searchSpace, length + 1);
1053lookUp = Unsafe.Add(ref searchSpace, length);
1064lookUp = Unsafe.Add(ref searchSpace, length + 3);
1070lookUp = Unsafe.Add(ref searchSpace, length + 2);
1076lookUp = Unsafe.Add(ref searchSpace, length + 1);
1082lookUp = Unsafe.Add(ref searchSpace, length);
1093lookUp = Unsafe.Add(ref searchSpace, length);
1104lookUp = Unsafe.Add(ref searchSpace, length);
1136T candidate = Unsafe.Add(ref searchSpace, i);
1139if (Unsafe.Add(ref value, j)!.Equals(candidate))
1150T candidate = Unsafe.Add(ref searchSpace, i);
1155if (candidate.Equals(Unsafe.Add(ref value, j)))
1165if (Unsafe.Add(ref value, j) is null)
1183if (!EqualityComparer<T>.Default.Equals(Unsafe.Add(ref searchSpace, i), value0))
1198if (!EqualityComparer<T>.Default.Equals(Unsafe.Add(ref searchSpace, i), value0))
1213ref T current = ref Unsafe.Add(ref searchSpace, i);
1229ref T current = ref Unsafe.Add(ref searchSpace, i);
1245ref T current = ref Unsafe.Add(ref searchSpace, i);
1263ref T current = ref Unsafe.Add(ref searchSpace, i);
1281ref T current = ref Unsafe.Add(ref searchSpace, i);
1300ref T current = ref Unsafe.Add(ref searchSpace, i);
1317if (Unsafe.AreSame(ref first, ref second))
1329lookUp0 = Unsafe.Add(ref first, index);
1330lookUp1 = Unsafe.Add(ref second, index);
1336lookUp0 = Unsafe.Add(ref first, index + 1);
1337lookUp1 = Unsafe.Add(ref second, index + 1);
1343lookUp0 = Unsafe.Add(ref first, index + 2);
1344lookUp1 = Unsafe.Add(ref second, index + 2);
1350lookUp0 = Unsafe.Add(ref first, index + 3);
1351lookUp1 = Unsafe.Add(ref second, index + 3);
1357lookUp0 = Unsafe.Add(ref first, index + 4);
1358lookUp1 = Unsafe.Add(ref second, index + 4);
1364lookUp0 = Unsafe.Add(ref first, index + 5);
1365lookUp1 = Unsafe.Add(ref second, index + 5);
1371lookUp0 = Unsafe.Add(ref first, index + 6);
1372lookUp1 = Unsafe.Add(ref second, index + 6);
1378lookUp0 = Unsafe.Add(ref first, index + 7);
1379lookUp1 = Unsafe.Add(ref second, index + 7);
1392lookUp0 = Unsafe.Add(ref first, index);
1393lookUp1 = Unsafe.Add(ref second, index);
1399lookUp0 = Unsafe.Add(ref first, index + 1);
1400lookUp1 = Unsafe.Add(ref second, index + 1);
1406lookUp0 = Unsafe.Add(ref first, index + 2);
1407lookUp1 = Unsafe.Add(ref second, index + 2);
1413lookUp0 = Unsafe.Add(ref first, index + 3);
1414lookUp1 = Unsafe.Add(ref second, index + 3);
1425lookUp0 = Unsafe.Add(ref first, index);
1426lookUp1 = Unsafe.Add(ref second, index);
1450T lookUp = Unsafe.Add(ref second, i);
1451int result = (Unsafe.Add(ref first, i)?.CompareTo(lookUp) ?? (((object?)lookUp is null) ? 0 : -1));
1466return PackedSpanHelpers.Contains(ref Unsafe.As<T, short>(ref searchSpace), Unsafe.BitCast<T, short>(value), length);
1485if (Unsafe.Add(ref searchSpace, offset) == value
1486|| Unsafe.Add(ref searchSpace, offset + 1) == value
1487|| Unsafe.Add(ref searchSpace, offset + 2) == value
1488|| Unsafe.Add(ref searchSpace, offset + 3) == value
1489|| Unsafe.Add(ref searchSpace, offset + 4) == value
1490|| Unsafe.Add(ref searchSpace, offset + 5) == value
1491|| Unsafe.Add(ref searchSpace, offset + 6) == value
1492|| Unsafe.Add(ref searchSpace, offset + 7) == value)
1504if (Unsafe.Add(ref searchSpace, offset) == value
1505|| Unsafe.Add(ref searchSpace, offset + 1) == value
1506|| Unsafe.Add(ref searchSpace, offset + 2) == value
1507|| Unsafe.Add(ref searchSpace, offset + 3) == value)
1519if (Unsafe.Add(ref searchSpace, offset) == value)
1531ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector512<T>.Count));
1543currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector512<T>.Count);
1545while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
1562ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector256<T>.Count));
1570currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<T>.Count);
1576while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
1592ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector128<T>.Count));
1600currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<T>.Count);
1606while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
1624=> IndexOfValueType(ref Unsafe.As<char, short>(ref searchSpace), (short)value, length);
1628=> LastIndexOfValueType(ref Unsafe.As<char, short>(ref searchSpace), (short)value, length);
1632NonPackedIndexOfValueType<short, DontNegate<short>>(ref Unsafe.As<char, short>(ref searchSpace), (short)value, length);
1650? PackedSpanHelpers.IndexOf(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value), length)
1651: PackedSpanHelpers.IndexOfAnyExcept(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value), length);
1672if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset) == value))
1676if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 1) == value))
1680if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 2) == value))
1684if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 3) == value))
1688if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 4) == value))
1692if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 5) == value))
1696if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 6) == value))
1700if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 7) == value))
1712if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset) == value))
1716if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 1) == value))
1720if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 2) == value))
1724if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset + 3) == value))
1736if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset) == value))
1750ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector512<TValue>.Count);
1762currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector512<TValue>.Count);
1764while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
1781ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count);
1789currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count);
1795while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
1811ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector128<TValue>.Count);
1819currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<TValue>.Count);
1825while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
1843=> IndexOfAnyValueType(ref Unsafe.As<char, short>(ref searchSpace), (short)value0, (short)value1, length);
1847=> LastIndexOfAnyValueType(ref Unsafe.As<char, short>(ref searchSpace), (short)value0, (short)value1, length);
1864char char0 = Unsafe.BitCast<TValue, char>(value0);
1865char char1 = Unsafe.BitCast<TValue, char>(value1);
1877? PackedSpanHelpers.IndexOfAnyIgnoreCase(ref Unsafe.As<TValue, char>(ref searchSpace), lowerCase, length)
1878: PackedSpanHelpers.IndexOfAnyExceptIgnoreCase(ref Unsafe.As<TValue, char>(ref searchSpace), lowerCase, length);
1883? PackedSpanHelpers.IndexOfAny(ref Unsafe.As<TValue, char>(ref searchSpace), char0, char1, length)
1884: PackedSpanHelpers.IndexOfAnyExcept(ref Unsafe.As<TValue, char>(ref searchSpace), char0, char1, length);
1909ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
1916lookUp = Unsafe.Add(ref current, 1);
1922lookUp = Unsafe.Add(ref current, 2);
1928lookUp = Unsafe.Add(ref current, 3);
1934lookUp = Unsafe.Add(ref current, 4);
1940lookUp = Unsafe.Add(ref current, 5);
1946lookUp = Unsafe.Add(ref current, 6);
1952lookUp = Unsafe.Add(ref current, 7);
1966ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
1973lookUp = Unsafe.Add(ref current, 1);
1979lookUp = Unsafe.Add(ref current, 2);
1985lookUp = Unsafe.Add(ref current, 3);
1998lookUp = Unsafe.Add(ref searchSpace, offset);
2013ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector512<TValue>.Count);
2022currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector512<TValue>.Count);
2028while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2045ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count);
2054currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count);
2060while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2077ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector128<TValue>.Count);
2086currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<TValue>.Count);
2092while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2125? PackedSpanHelpers.IndexOfAny(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value0), Unsafe.BitCast<TValue, char>(value1), Unsafe.BitCast<TValue, char>(value2), length)
2126: PackedSpanHelpers.IndexOfAnyExcept(ref Unsafe.As<TValue, char>(ref searchSpace), Unsafe.BitCast<TValue, char>(value0), Unsafe.BitCast<TValue, char>(value1), Unsafe.BitCast<TValue, char>(value2), length);
2150ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
2157lookUp = Unsafe.Add(ref current, 1);
2163lookUp = Unsafe.Add(ref current, 2);
2169lookUp = Unsafe.Add(ref current, 3);
2175lookUp = Unsafe.Add(ref current, 4);
2181lookUp = Unsafe.Add(ref current, 5);
2187lookUp = Unsafe.Add(ref current, 6);
2193lookUp = Unsafe.Add(ref current, 7);
2207ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
2214lookUp = Unsafe.Add(ref current, 1);
2220lookUp = Unsafe.Add(ref current, 2);
2226lookUp = Unsafe.Add(ref current, 3);
2239lookUp = Unsafe.Add(ref searchSpace, offset);
2254ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector512<TValue>.Count);
2263currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector512<TValue>.Count);
2269while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2286ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count);
2295currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count);
2301while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2318ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector128<TValue>.Count);
2327currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<TValue>.Count);
2333while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2374ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
2381lookUp = Unsafe.Add(ref current, 1);
2387lookUp = Unsafe.Add(ref current, 2);
2393lookUp = Unsafe.Add(ref current, 3);
2406lookUp = Unsafe.Add(ref searchSpace, offset);
2421ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector512<TValue>.Count);
2431currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector512<TValue>.Count);
2437while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2455ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector256<TValue>.Count);
2465currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count);
2471while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2489ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, length - Vector128<TValue>.Count);
2499currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<TValue>.Count);
2505while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2547ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
2554lookUp = Unsafe.Add(ref current, 1);
2560lookUp = Unsafe.Add(ref current, 2);
2566lookUp = Unsafe.Add(ref current, 3);
2579lookUp = Unsafe.Add(ref searchSpace, offset);
2595ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector512<TValue>.Count));
2605currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector512<TValue>.Count);
2611while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2630ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector256<TValue>.Count));
2640currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<TValue>.Count);
2646while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2665ref TValue oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector128<TValue>.Count));
2675currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<TValue>.Count);
2681while (Unsafe.IsAddressLessThanOrEqualTo(ref currentSearchSpace, ref oneVectorAwayFromEnd));
2722if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset) == value))
2726if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 1) == value))
2730if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 2) == value))
2734if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 3) == value))
2738if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 4) == value))
2742if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 5) == value))
2746if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 6) == value))
2750if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 7) == value))
2762if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset) == value))
2766if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 1) == value))
2770if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 2) == value))
2774if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset - 3) == value))
2786if (TNegator.NegateIfNeeded(Unsafe.Add(ref searchSpace, offset) == value))
2869ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
2876lookUp = Unsafe.Add(ref current, -1);
2882lookUp = Unsafe.Add(ref current, -2);
2888lookUp = Unsafe.Add(ref current, -3);
2894lookUp = Unsafe.Add(ref current, -4);
2900lookUp = Unsafe.Add(ref current, -5);
2906lookUp = Unsafe.Add(ref current, -6);
2912lookUp = Unsafe.Add(ref current, -7);
2926ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
2933lookUp = Unsafe.Add(ref current, -1);
2939lookUp = Unsafe.Add(ref current, -2);
2945lookUp = Unsafe.Add(ref current, -3);
2958lookUp = Unsafe.Add(ref searchSpace, offset);
3086ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
3093lookUp = Unsafe.Add(ref current, -1);
3099lookUp = Unsafe.Add(ref current, -2);
3105lookUp = Unsafe.Add(ref current, -3);
3111lookUp = Unsafe.Add(ref current, -4);
3117lookUp = Unsafe.Add(ref current, -5);
3123lookUp = Unsafe.Add(ref current, -6);
3129lookUp = Unsafe.Add(ref current, -7);
3143ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
3150lookUp = Unsafe.Add(ref current, -1);
3156lookUp = Unsafe.Add(ref current, -2);
3162lookUp = Unsafe.Add(ref current, -3);
3175lookUp = Unsafe.Add(ref searchSpace, offset);
3301ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
3308lookUp = Unsafe.Add(ref current, -1);
3314lookUp = Unsafe.Add(ref current, -2);
3320lookUp = Unsafe.Add(ref current, -3);
3333lookUp = Unsafe.Add(ref searchSpace, offset);
3440T original = Unsafe.Add(ref src, idx);
3441Unsafe.Add(ref dst, idx) = oldValue.Equals(original) ? newValue : original;
3448T original = Unsafe.Add(ref src, idx);
3449Unsafe.Add(ref dst, idx) = original is null ? newValue : original;
3460T original = Unsafe.Add(ref src, idx);
3461Unsafe.Add(ref dst, idx) = EqualityComparer<T>.Default.Equals(original, oldValue) ? newValue : original;
3573ref TValue current = ref Unsafe.Add(ref searchSpace, offset);
3580lookUp = Unsafe.Add(ref current, -1);
3586lookUp = Unsafe.Add(ref current, -2);
3592lookUp = Unsafe.Add(ref current, -3);
3605lookUp = Unsafe.Add(ref searchSpace, offset);
3718return index + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
3726return index + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
3734return index + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
3831ref T current = ref Unsafe.Add(ref searchSpace, i);
3846ref T current = ref Unsafe.Add(ref searchSpace, i);
3871ref char charSearchSpace = ref Unsafe.As<T, char>(ref searchSpace);
3872char charLowInclusive = Unsafe.BitCast<T, char>(lowInclusive);
3873char charRange = (char)(Unsafe.BitCast<T, char>(highInclusive) - charLowInclusive);
3894ref T current = ref Unsafe.Add(ref searchSpace, i);
3908ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector128<T>.Count));
3919current = ref Unsafe.Add(ref current, Vector128<T>.Count);
3921while (Unsafe.IsAddressLessThan(ref current, ref oneVectorAwayFromEnd));
3937ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector256<T>.Count));
3948current = ref Unsafe.Add(ref current, Vector256<T>.Count);
3950while (Unsafe.IsAddressLessThan(ref current, ref oneVectorAwayFromEnd));
3966ref T oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, (uint)(length - Vector512<T>.Count));
3977current = ref Unsafe.Add(ref current, Vector512<T>.Count);
3979while (Unsafe.IsAddressLessThan(ref current, ref oneVectorAwayFromEnd));
3997ref T current = ref Unsafe.Add(ref searchSpace, i);
4012ref T current = ref Unsafe.Add(ref searchSpace, i);
4041ref T current = ref Unsafe.Add(ref searchSpace, i);
4137ref T end = ref Unsafe.Add(ref current, length);
4140while (Unsafe.IsAddressLessThan(ref current, ref end))
4147current = ref Unsafe.Add(ref current, 1);
4152while (Unsafe.IsAddressLessThan(ref current, ref end))
4159current = ref Unsafe.Add(ref current, 1);
4169ref T end = ref Unsafe.Add(ref current, length);
4176ref T oneVectorAwayFromEnd = ref Unsafe.Subtract(ref end, Vector512<T>.Count);
4177while (Unsafe.IsAddressLessThan(ref current, ref oneVectorAwayFromEnd))
4180current = ref Unsafe.Add(ref current, Vector512<T>.Count);
4185mask >>= (int)((nuint)Unsafe.ByteOffset(ref oneVectorAwayFromEnd, ref current) / (uint)sizeof(T));
4191ref T oneVectorAwayFromEnd = ref Unsafe.Subtract(ref end, Vector256<T>.Count);
4192while (Unsafe.IsAddressLessThan(ref current, ref oneVectorAwayFromEnd))
4195current = ref Unsafe.Add(ref current, Vector256<T>.Count);
4200mask >>= (int)((nuint)Unsafe.ByteOffset(ref oneVectorAwayFromEnd, ref current) / (uint)sizeof(T));
4206ref T oneVectorAwayFromEnd = ref Unsafe.Subtract(ref end, Vector128<T>.Count);
4207while (Unsafe.IsAddressLessThan(ref current, ref oneVectorAwayFromEnd))
4210current = ref Unsafe.Add(ref current, Vector128<T>.Count);
4215mask >>= (int)((nuint)Unsafe.ByteOffset(ref oneVectorAwayFromEnd, ref current) / (uint)sizeof(T));
4221while (Unsafe.IsAddressLessThan(ref current, ref end))
4228current = ref Unsafe.Add(ref current, 1);
src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (22)
46ref Unsafe.Add(ref strA.GetRawStringData(), (nint)(uint)indexA /* force zero-extension */), countA,
47ref Unsafe.Add(ref strB.GetRawStringData(), (nint)(uint)indexB /* force zero-extension */), countB);
77if (Unsafe.Add(ref strA._firstChar, 1) != Unsafe.Add(ref strB._firstChar, 1)) goto DiffOffset1;
87ref Unsafe.Add(ref strA._firstChar, 2), strA.Length - 2,
88ref Unsafe.Add(ref strB._firstChar, 2), strB.Length - 2);
99return Unsafe.Add(ref strA._firstChar, 1) - Unsafe.Add(ref strB._firstChar, 1);
321return Ordinal.CompareStringIgnoreCase(ref Unsafe.Add(ref strA.GetRawStringData(), indexA), lengthA, ref Unsafe.Add(ref strB.GetRawStringData(), indexB), lengthB);
463Ordinal.EqualsIgnoreCase(ref Unsafe.Add(ref GetRawStringData(), Length - value.Length),
498return Unsafe.Add(ref _firstChar, (nint)localLength - 1) == value;
689return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref _firstChar), (uint)_stringLength * 2 /* in bytes, not chars */, (uint)seed, (uint)(seed >> 32));
710return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(value)), (uint)value.Length * 2 /* in bytes, not chars */, (uint)seed, (uint)(seed >> 32));
808hash1 = BitOperations.RotateLeft(hash1, 5) + hash1 ^ Unsafe.ReadUnaligned<uint>(ptr);
809hash2 = BitOperations.RotateLeft(hash2, 5) + hash2 ^ Unsafe.ReadUnaligned<uint>(ptr + 1);
816hash1 = BitOperations.RotateLeft(hash1, 5) + hash1 ^ Unsafe.ReadUnaligned<uint>(ptr);
827hash2 = BitOperations.RotateLeft(hash2, 5) + hash2 ^ Unsafe.ReadUnaligned<uint>(ptr);
918p0 = Unsafe.ReadUnaligned<uint>(ptr);
919p1 = Unsafe.ReadUnaligned<uint>(ptr + 1);
934p0 = Unsafe.ReadUnaligned<uint>(ptr);
951p0 = Unsafe.ReadUnaligned<uint>(ptr);
src\libraries\System.Private.CoreLib\src\System\String.cs (9)
112source: ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(value), startIndex));
386slice = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, (nint)(uint)startIndex /* force zero-extension */), count);
427destination: ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), destinationIndex),
428source: ref Unsafe.Add(ref _firstChar, sourceIndex),
497source: ref Unsafe.Add(ref _firstChar, startIndex),
528internal ref byte GetRawStringDataAsUInt8() => ref Unsafe.As<char, byte>(ref _firstChar);
529internal ref ushort GetRawStringDataAsUInt16() => ref Unsafe.As<char, ushort>(ref _firstChar);
573Unsafe.Add(ref result._firstChar, 1) = c2;
735return Unsafe.Add(ref _firstChar, (nint)(uint)index /* force zero-extension */);
src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (24)
63destination: ref Unsafe.Add(ref dest._firstChar, destPos),
709Buffer.Memmove(ref Unsafe.Add(ref result._firstChar, startIndex), ref value._firstChar, (nuint)insertLength);
710Buffer.Memmove(ref Unsafe.Add(ref result._firstChar, startIndex + insertLength), ref Unsafe.Add(ref _firstChar, startIndex), (nuint)(oldLength - startIndex));
946IEnumerator<char> en = Unsafe.As<IEnumerator<char>>(e);
1097ref char dest = ref Unsafe.Add(ref result._firstChar, copiedLength);
1134Buffer.Memmove(ref Unsafe.Add(ref result._firstChar, count), ref _firstChar, (nuint)oldLength);
1152new Span<char>(ref Unsafe.Add(ref result._firstChar, oldLength), count).Fill(paddingChar);
1173Buffer.Memmove(ref Unsafe.Add(ref result._firstChar, startIndex), ref Unsafe.Add(ref _firstChar, startIndex + count), (nuint)(newLength - startIndex));
1289ref ushort pSrc = ref Unsafe.Add(ref GetRawStringDataAsUInt16(), (uint)copyLength);
1290ref ushort pDst = ref Unsafe.Add(ref result.GetRawStringDataAsUInt16(), (uint)copyLength);
1299pSrc = ref Unsafe.Subtract(ref pSrc, adjust);
1300pDst = ref Unsafe.Subtract(ref pDst, adjust);
1306pSrc = ref Unsafe.Subtract(ref pSrc, adjust);
1307pDst = ref Unsafe.Subtract(ref pDst, adjust);
1313pSrc = ref Unsafe.Subtract(ref pSrc, adjust);
1314pDst = ref Unsafe.Subtract(ref pDst, adjust);
1353int pos = PackedSpanHelpers.IndexOf(ref Unsafe.Add(ref _firstChar, i), c, Length - i);
1366int pos = SpanHelpers.NonPackedIndexOfChar(ref Unsafe.Add(ref _firstChar, i), c, Length - i);
1382int pos = SpanHelpers.IndexOf(ref Unsafe.Add(ref _firstChar, i), Length - i, ref oldValue._firstChar, oldValue.Length);
2075ref uint charMap = ref Unsafe.As<ProbabilisticMap, uint>(ref map);
2190char curr = Unsafe.Add(ref source, offset);
2346source: ref Unsafe.Add(ref _firstChar, (nint)(uint)startIndex /* force zero-extension */));
src\libraries\System.Private.CoreLib\src\System\String.Searching.cs (9)
39=> SpanHelpers.ContainsValueType(ref Unsafe.As<char, short>(ref _firstChar), (short)value, Length);
136ref char startChar = ref Unsafe.Add(ref _firstChar, startIndex);
171int result = SpanHelpers.IndexOfChar(ref Unsafe.Add(ref _firstChar, startIndex), value, count);
211int result = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, startIndex), count).IndexOfAny(anyOf);
446=> SpanHelpers.LastIndexOfValueType(ref Unsafe.As<char, short>(ref _firstChar), (short)value, Length);
471int result = SpanHelpers.LastIndexOfValueType(ref Unsafe.As<char, short>(ref Unsafe.Add(ref _firstChar, startSearchAt)), (short)value, count);
551ref char startChar = ref Unsafe.Add(ref _firstChar, startSearchAt);
620int result = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, startSearchAt), count).LastIndexOfAny(anyOf);
src\libraries\System.Private.CoreLib\src\System\Text\Ascii.cs (36)
32IsValidCore(ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(value)), value.Length);
62Unsafe.ReadUnaligned<uint>(ref Unsafe.As<T, byte>(ref searchSpace)) |
63Unsafe.ReadUnaligned<uint>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref searchSpace, length - sizeof(uint)))));
70? (Unsafe.BitCast<T, byte>(Unsafe.Add(ref searchSpace, j)) > 127)
71: (Unsafe.BitCast<T, char>(Unsafe.Add(ref searchSpace, j)) > 127))
90Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref searchSpace, i))) |
91Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref searchSpace, i + elementsPerUlong)))))
102Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref searchSpace, i))) |
103Unsafe.ReadUnaligned<ulong>(ref Unsafe.Subtract(ref Unsafe.As<T, byte>(ref Unsafe.Add(ref searchSpace, length)), sizeof(ulong))));
106ref T searchSpaceEnd = ref Unsafe.Add(ref searchSpace, length);
113Vector128.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, Vector128<T>.Count)));
123Vector256.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, Vector256<T>.Count)));
144nuint misalignedElements = Unsafe.OpportunisticMisalignment(ref searchSpace, (uint)Vector256<byte>.Count) / (nuint)sizeof(T);
152ref T current = ref Unsafe.Add(ref searchSpace, i);
164searchSpace = ref Unsafe.Add(ref searchSpace, finalStart);
173Vector256.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, 2 * Vector256<T>.Count)) |
174Vector256.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, Vector256<T>.Count)));
196nuint misalignedElements = Unsafe.OpportunisticMisalignment(ref searchSpace, (uint)Vector128<byte>.Count) / (nuint)sizeof(T);
204ref T current = ref Unsafe.Add(ref searchSpace, i);
216searchSpace = ref Unsafe.Add(ref searchSpace, finalStart);
225Vector128.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, 2 * Vector128<T>.Count)) |
226Vector128.LoadUnsafe(ref Unsafe.Subtract(ref searchSpaceEnd, Vector128<T>.Count)));
src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Equality.cs (44)
31&& Equals<byte, ushort, WideningLoader>(ref MemoryMarshal.GetReference(left), ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(right)), (uint)right.Length);
40&& Equals<ushort, ushort, PlainLoader<ushort>>(ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(left)), ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(right)), (uint)right.Length);
56uint valueA = uint.CreateTruncating(Unsafe.Add(ref left, i));
57uint valueB = uint.CreateTruncating(Unsafe.Add(ref right, i));
73ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector512<TLeft>.Count);
83currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, Vector512<TLeft>.Count);
84currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, Vector512<TLeft>.Count);
86while (Unsafe.IsAddressLessThanOrEqualTo(ref currentRightSearchSpace, ref oneVectorAwayFromRightEnd));
91ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref left, length - (uint)Vector512<TLeft>.Count);
103ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector256<TLeft>.Count);
113currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, Vector256<TLeft>.Count);
114currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, Vector256<TLeft>.Count);
116while (Unsafe.IsAddressLessThanOrEqualTo(ref currentRightSearchSpace, ref oneVectorAwayFromRightEnd));
121ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref left, length - (uint)Vector256<TLeft>.Count);
128ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref currentLeftSearchSpace, length - (uint)Vector128<TRight>.Count);
130ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector128<TRight>.Count);
147currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, (uint)Vector128<TRight>.Count);
148currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, (uint)Vector128<TRight>.Count);
150while (Unsafe.IsAddressLessThanOrEqualTo(ref currentRightSearchSpace, ref oneVectorAwayFromRightEnd));
182&& EqualsIgnoreCase<byte, ushort, WideningLoader>(ref MemoryMarshal.GetReference(left), ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(right)), (uint)right.Length);
191&& EqualsIgnoreCase<ushort, ushort, PlainLoader<ushort>>(ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(left)), ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(right)), (uint)right.Length);
194EqualsIgnoreCase<ushort, ushort, PlainLoader<ushort>>(ref Unsafe.As<char, ushort>(ref left), ref Unsafe.As<char, ushort>(ref right), length);
210uint valueA = uint.CreateTruncating(Unsafe.Add(ref left, i));
211uint valueB = uint.CreateTruncating(Unsafe.Add(ref right, i));
238ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref currentLeftSearchSpace, length - (uint)Vector512<TRight>.Count);
240ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector512<TRight>.Count);
274currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, (uint)Vector512<TRight>.Count);
275currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, (uint)Vector512<TRight>.Count);
277while (Unsafe.IsAddressLessThanOrEqualTo(ref currentRightSearchSpace, ref oneVectorAwayFromRightEnd));
309ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref currentLeftSearchSpace, length - (uint)Vector256<TRight>.Count);
311ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector256<TRight>.Count);
346currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, (uint)Vector256<TRight>.Count);
347currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, (uint)Vector256<TRight>.Count);
349while (Unsafe.IsAddressLessThanOrEqualTo(ref currentRightSearchSpace, ref oneVectorAwayFromRightEnd));
381ref TLeft oneVectorAwayFromLeftEnd = ref Unsafe.Add(ref currentLeftSearchSpace, length - (uint)Vector128<TRight>.Count);
383ref TRight oneVectorAwayFromRightEnd = ref Unsafe.Add(ref currentRightSearchSpace, length - (uint)Vector128<TRight>.Count);
419currentRightSearchSpace = ref Unsafe.Add(ref currentRightSearchSpace, (uint)Vector128<TRight>.Count);
420currentLeftSearchSpace = ref Unsafe.Add(ref currentLeftSearchSpace, (uint)Vector128<TRight>.Count);
422while (Unsafe.IsAddressLessThanOrEqualTo(ref currentRightSearchSpace, ref oneVectorAwayFromRightEnd));
513Vector128<byte> vec = Vector128.CreateScalarUnsafe(Unsafe.ReadUnaligned<long>(ref ptr)).AsByte();
518Vector128<byte> vec = Vector128.CreateScalarUnsafe(Unsafe.ReadUnaligned<long>(ref ptr)).AsByte();
src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Utility.cs (45)
266currentUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer);
267uint nextUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer + 4);
291currentUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer);
304currentUInt32 = Unsafe.ReadUnaligned<ushort>(pBuffer);
639ulong candidateUInt64 = Unsafe.ReadUnaligned<ulong>(pBuffer);
654currentDWord = Unsafe.ReadUnaligned<uint>(pBuffer);
655uint nextDWord = Unsafe.ReadUnaligned<uint>(pBuffer + 4);
679currentDWord = Unsafe.ReadUnaligned<uint>(pBuffer);
694currentDWord = Unsafe.ReadUnaligned<ushort>(pBuffer);
888currentUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer);
889uint nextUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer + 4 / sizeof(char));
913currentUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer);
1195ulong candidateUInt64 = Unsafe.ReadUnaligned<ulong>(pBuffer);
1212currentDWord = Unsafe.ReadUnaligned<uint>(pBuffer);
1213uint nextDWord = Unsafe.ReadUnaligned<uint>(pBuffer + 4 / sizeof(char));
1237currentDWord = Unsafe.ReadUnaligned<uint>(pBuffer);
1280Unsafe.WriteUnaligned(ref outputBuffer, Sse2.ConvertToUInt32(vecNarrow));
1289Unsafe.WriteUnaligned(ref outputBuffer, lower.AsUInt32().ToScalar());
1298Unsafe.Add(ref outputBuffer, 1) = (byte)value;
1300Unsafe.Add(ref outputBuffer, 2) = (byte)value;
1302Unsafe.Add(ref outputBuffer, 3) = (byte)value;
1306Unsafe.Add(ref outputBuffer, 3) = (byte)value;
1308Unsafe.Add(ref outputBuffer, 2) = (byte)value;
1310Unsafe.Add(ref outputBuffer, 1) = (byte)value;
1330Unsafe.Add(ref outputBuffer, 1) = (byte)(value >> 16);
1334Unsafe.Add(ref outputBuffer, 1) = (byte)value;
1361utf16Data64Bits = Unsafe.ReadUnaligned<ulong>(pUtf16Buffer);
1369utf16Data32BitsHigh = Unsafe.ReadUnaligned<uint>(pUtf16Buffer);
1370utf16Data32BitsLow = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + 4 / sizeof(char));
1405utf16Data64Bits = Unsafe.ReadUnaligned<ulong>(pUtf16Buffer + currentOffset);
1415utf16Data32BitsHigh = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + currentOffset);
1416utf16Data32BitsLow = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + currentOffset + 4 / sizeof(char));
1434utf16Data32BitsHigh = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + currentOffset);
2106asciiData = Unsafe.ReadUnaligned<uint>(pAsciiBuffer + currentOffset);
2121asciiData = Unsafe.ReadUnaligned<ushort>(pAsciiBuffer + currentOffset);
2285Unsafe.WriteUnaligned(ref Unsafe.As<char, byte>(ref outputBuffer), vecWide.ToScalar());
2291Unsafe.WriteUnaligned(ref Unsafe.As<char, byte>(ref outputBuffer), vecWide.ToScalar());
2300Unsafe.Add(ref outputBuffer, 1) = (char)(byte)value;
2302Unsafe.Add(ref outputBuffer, 2) = (char)(byte)value;
2304Unsafe.Add(ref outputBuffer, 3) = (char)value;
2308Unsafe.Add(ref outputBuffer, 3) = (char)(byte)value;
2310Unsafe.Add(ref outputBuffer, 2) = (char)(byte)value;
2312Unsafe.Add(ref outputBuffer, 1) = (char)(byte)value;
src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (12)
272pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
365pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
549pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
551pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
652pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
654pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
872pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
961pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
1152pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
1154pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
1252pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
1254pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (8)
342ref Unsafe.Add(ref result.GetRawStringData(), chunkOffset),
797Append(ref Unsafe.Add(ref value.GetRawStringData(), startIndex), count);
1262Debug.Assert(!Unsafe.IsNullRef(ref separator));
2346ref char destination = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(chunkChars), chunkLength);
2352Unsafe.Add(ref destination, 1) = Unsafe.Add(ref value, 1);
2393new ReadOnlySpan<char>(ref Unsafe.Add(ref value, firstLength), restLength).CopyTo(m_ChunkChars);
2560value = ref Unsafe.Add(ref value, lengthToCopy);
src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Helpers.cs (12)
736Unsafe.WriteUnaligned(ref outputBuffer, tempA + tempB + 0xE080_80E0u); // = [ 1110ZZZZ 10xxxxxx 10yyyyyy 1110zzzz ]
737Unsafe.WriteUnaligned(ref Unsafe.Add(ref outputBuffer, 4), (ushort)(((value >> 22) & 0x3Fu) + ((value >> 8) & 0x3F00u) + 0x8080u)); // = [ 10XXXXXX 10YYYYYY ]
744Unsafe.Add(ref outputBuffer, 5) = (byte)((value & 0x3Fu) | 0x80u);
745Unsafe.Add(ref outputBuffer, 4) = (byte)(((value >>= 6) & 0x3Fu) | 0x80u);
746Unsafe.Add(ref outputBuffer, 3) = (byte)(((value >>= 6) & 0x0Fu) | 0xE0u);
747Unsafe.Add(ref outputBuffer, 2) = (byte)(((value >>= 4) & 0x3Fu) | 0x80u);
748Unsafe.Add(ref outputBuffer, 1) = (byte)(((value >>= 6) & 0x3Fu) | 0x80u);
770Unsafe.WriteUnaligned(ref outputBuffer, (ushort)(tempA + tempB + 0x80E0u)); // [ 10yyyyyy 1110zzzz ]
771Unsafe.Add(ref outputBuffer, 2) = (byte)((value & 0x3Fu) | ~0x7Fu); // [ 10xxxxxx ]
778Unsafe.Add(ref outputBuffer, 2) = (byte)(((value >>= 16) & 0x3Fu) | 0x80u);
779Unsafe.Add(ref outputBuffer, 1) = (byte)(((value >>= 6) & 0x3Fu) | 0x80u);
src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Transcoding.cs (36)
69uint thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
96uint remainingInputBytes = (uint)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *pFinalPosWhereCanReadDWordFromInputBuffer) + 4;
104thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
105secondDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer + sizeof(uint));
245thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
289Unsafe.WriteUnaligned(pOutputBuffer, ExtractTwoCharsPackedFromTwoAdjacentTwoByteSequences(thisDWord));
300thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
389thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
412thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
487if (outputCharsRemaining > 1 && (nint)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *pFinalPosWhereCanReadDWordFromInputBuffer) >= 3)
496uint secondDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer + 3);
552thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
629Unsafe.WriteUnaligned(pOutputBuffer, ExtractCharsFromFourByteSequence(thisDWord));
640inputLength = (int)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *pFinalPosWhereCanReadDWordFromInputBuffer) + 4;
905thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
933Unsafe.WriteUnaligned(pOutputBuffer, (ushort)valueToWrite);
957Unsafe.SkipInit(out nonAsciiUtf16DataMask);
959utf16Data = Unsafe.ReadUnaligned<Vector128<short>>(pInputBuffer);
1000possibleNonAsciiQWord = Unsafe.ReadUnaligned<ulong>(pInputBuffer);
1015Unsafe.WriteUnaligned(pOutputBuffer, Sse2.ConvertToUInt32(Sse2.PackUnsignedSaturate(utf16Data, utf16Data).AsUInt32()));
1058Unsafe.WriteUnaligned(pOutputBuffer, Sse2.ConvertToUInt32(Sse2.PackUnsignedSaturate(utf16Data, utf16Data).AsUInt32()));
1079Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(thisDWord | (thisDWord >> 8)));
1097thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1098secondDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer + 2);
1107Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(thisDWord | (thisDWord >> 8)));
1108Unsafe.WriteUnaligned(pOutputBuffer + 2, (ushort)(secondDWord | (secondDWord >> 8)));
1128Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(thisDWord | (thisDWord >> 8)));
1174thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1196Unsafe.WriteUnaligned(pOutputBuffer, ExtractTwoUtf8TwoByteSequencesFromTwoPackedUtf16Chars(thisDWord));
1211thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1230Unsafe.WriteUnaligned(pOutputBuffer, (ushort)ExtractUtf8TwoByteSequenceFromFirstUtf16Char(thisDWord));
1271thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1310thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1368thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1388thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1402Unsafe.WriteUnaligned(pOutputBuffer, ExtractFourUtf8BytesFromSurrogatePair(thisDWord));
src\libraries\System.Private.CoreLib\src\System\Threading\Interlocked.cs (95)
42(uint)Add(ref Unsafe.As<uint, int>(ref location), -1);
51(ulong)Add(ref Unsafe.As<ulong, long>(ref location), -1);
64(sbyte)Exchange(ref Unsafe.As<sbyte, byte>(ref location1), (byte)value);
74(short)Exchange(ref Unsafe.As<short, ushort>(ref location1), (ushort)value);
162(uint)Exchange(ref Unsafe.As<uint, int>(ref location1), (int)value);
173(ulong)Exchange(ref Unsafe.As<ulong, long>(ref location1), (long)value);
182=> Unsafe.BitCast<int, float>(Exchange(ref Unsafe.As<float, int>(ref location1), Unsafe.BitCast<float, int>(value)));
191=> Unsafe.BitCast<long, double>(Exchange(ref Unsafe.As<double, long>(ref location1), Unsafe.BitCast<double, long>(value)));
203return (nint)Exchange(ref Unsafe.As<nint, long>(ref location1), (long)value);
220return (nuint)Exchange(ref Unsafe.As<nuint, long>(ref location1), (long)value);
244object? result = Exchange(ref Unsafe.As<T, object?>(ref location1), value);
245return Unsafe.As<object?, T>(ref result);
257return Unsafe.BitCast<byte, T>(
259ref Unsafe.As<T, byte>(ref location1),
260Unsafe.BitCast<T, byte>(value)));
265return Unsafe.BitCast<ushort, T>(
267ref Unsafe.As<T, ushort>(ref location1),
268Unsafe.BitCast<T, ushort>(value)));
273return Unsafe.BitCast<int, T>(
275ref Unsafe.As<T, int>(ref location1),
276Unsafe.BitCast<T, int>(value)));
280return Unsafe.BitCast<long, T>(
282ref Unsafe.As<T, long>(ref location1),
283Unsafe.BitCast<T, long>(value)));
298(sbyte)CompareExchange(ref Unsafe.As<sbyte, byte>(ref location1), (byte)value, (byte)comparand);
309(short)CompareExchange(ref Unsafe.As<short, ushort>(ref location1), (ushort)value, (ushort)comparand);
406(uint)CompareExchange(ref Unsafe.As<uint, int>(ref location1), (int)value, (int)comparand);
418(ulong)CompareExchange(ref Unsafe.As<ulong, long>(ref location1), (long)value, (long)comparand);
428=> Unsafe.BitCast<int, float>(CompareExchange(ref Unsafe.As<float, int>(ref location1), Unsafe.BitCast<float, int>(value), Unsafe.BitCast<float, int>(comparand)));
438=> Unsafe.BitCast<long, double>(CompareExchange(ref Unsafe.As<double, long>(ref location1), Unsafe.BitCast<double, long>(value), Unsafe.BitCast<double, long>(comparand)));
451return (nint)CompareExchange(ref Unsafe.As<nint, long>(ref location1), (long)value, (long)comparand);
469return (nuint)CompareExchange(ref Unsafe.As<nuint, long>(ref location1), (long)value, (long)comparand);
494object? result = CompareExchange(ref Unsafe.As<T, object?>(ref location1), value, comparand);
495return Unsafe.As<object?, T>(ref result);
507return Unsafe.BitCast<byte, T>(
509ref Unsafe.As<T, byte>(ref location1),
510Unsafe.BitCast<T, byte>(value),
511Unsafe.BitCast<T, byte>(comparand)));
516return Unsafe.BitCast<ushort, T>(
518ref Unsafe.As<T, ushort>(ref location1),
519Unsafe.BitCast<T, ushort>(value),
520Unsafe.BitCast<T, ushort>(comparand)));
525return Unsafe.BitCast<int, T>(
527ref Unsafe.As<T, int>(ref location1),
528Unsafe.BitCast<T, int>(value),
529Unsafe.BitCast<T, int>(comparand)));
533return Unsafe.BitCast<long, T>(
535ref Unsafe.As<T, long>(ref location1),
536Unsafe.BitCast<T, long>(value),
537Unsafe.BitCast<T, long>(comparand)));
550(uint)Add(ref Unsafe.As<uint, int>(ref location1), (int)value);
560(ulong)Add(ref Unsafe.As<ulong, long>(ref location1), (long)value);
570CompareExchange(ref Unsafe.AsRef(in location), 0, 0);
604(uint)And(ref Unsafe.As<uint, int>(ref location1), (int)value);
636(ulong)And(ref Unsafe.As<ulong, long>(ref location1), (long)value);
666byte current = Unsafe.BitCast<T, byte>(location1);
669byte newValue = (byte)(current & Unsafe.BitCast<T, byte>(value));
671ref Unsafe.As<T, byte>(ref location1),
676return Unsafe.BitCast<byte, T>(oldValue);
684ushort current = Unsafe.BitCast<T, ushort>(location1);
687ushort newValue = (ushort)(current & Unsafe.BitCast<T, ushort>(value));
689ref Unsafe.As<T, ushort>(ref location1),
694return Unsafe.BitCast<ushort, T>(oldValue);
702return Unsafe.BitCast<int, T>(
704ref Unsafe.As<T, int>(ref location1),
705Unsafe.BitCast<T, int>(value)));
709return Unsafe.BitCast<long, T>(
711ref Unsafe.As<T, long>(ref location1),
712Unsafe.BitCast<T, long>(value)));
747(uint)Or(ref Unsafe.As<uint, int>(ref location1), (int)value);
779(ulong)Or(ref Unsafe.As<ulong, long>(ref location1), (long)value);
809byte current = Unsafe.BitCast<T, byte>(location1);
812byte newValue = (byte)(current | Unsafe.BitCast<T, byte>(value));
814ref Unsafe.As<T, byte>(ref location1),
819return Unsafe.BitCast<byte, T>(oldValue);
827ushort current = Unsafe.BitCast<T, ushort>(location1);
830ushort newValue = (ushort)(current | Unsafe.BitCast<T, ushort>(value));
832ref Unsafe.As<T, ushort>(ref location1),
837return Unsafe.BitCast<ushort, T>(oldValue);
845return Unsafe.BitCast<int, T>(
847ref Unsafe.As<T, int>(ref location1),
848Unsafe.BitCast<T, int>(value)));
852return Unsafe.BitCast<long, T>(
854ref Unsafe.As<T, long>(ref location1),
855Unsafe.BitCast<T, long>(value)));
src\libraries\System.Private.CoreLib\src\System\Threading\Volatile.cs (43)
22Unsafe.As<bool, VolatileBoolean>(ref Unsafe.AsRef(in location)).Value;
27Unsafe.As<bool, VolatileBoolean>(ref location).Value = value;
36Unsafe.As<byte, VolatileByte>(ref Unsafe.AsRef(in location)).Value;
41Unsafe.As<byte, VolatileByte>(ref location).Value = value;
49long result = Read(ref Unsafe.As<double, long>(ref Unsafe.AsRef(in location)));
56Write(ref Unsafe.As<double, long>(ref location), BitConverter.DoubleToInt64Bits(value));
65Unsafe.As<short, VolatileInt16>(ref Unsafe.AsRef(in location)).Value;
70Unsafe.As<short, VolatileInt16>(ref location).Value = value;
79Unsafe.As<int, VolatileInt32>(ref Unsafe.AsRef(in location)).Value;
84Unsafe.As<int, VolatileInt32>(ref location).Value = value;
92(long)Unsafe.As<long, VolatileIntPtr>(ref Unsafe.AsRef(in location)).Value;
102Unsafe.As<long, VolatileIntPtr>(ref location).Value = (nint)value;
115Unsafe.As<nint, VolatileIntPtr>(ref Unsafe.AsRef(in location)).Value;
120Unsafe.As<nint, VolatileIntPtr>(ref location).Value = value;
130Unsafe.As<sbyte, VolatileSByte>(ref Unsafe.AsRef(in location)).Value;
136Unsafe.As<sbyte, VolatileSByte>(ref location).Value = value;
145Unsafe.As<float, VolatileSingle>(ref Unsafe.AsRef(in location)).Value;
150Unsafe.As<float, VolatileSingle>(ref location).Value = value;
160Unsafe.As<ushort, VolatileUInt16>(ref Unsafe.AsRef(in location)).Value;
166Unsafe.As<ushort, VolatileUInt16>(ref location).Value = value;
176Unsafe.As<uint, VolatileUInt32>(ref Unsafe.AsRef(in location)).Value;
182Unsafe.As<uint, VolatileUInt32>(ref location).Value = value;
190(ulong)Read(ref Unsafe.As<ulong, long>(ref Unsafe.AsRef(in location)));
196Write(ref Unsafe.As<ulong, long>(ref location), (long)value);
206Unsafe.As<nuint, VolatileUIntPtr>(ref Unsafe.AsRef(in location)).Value;
212Unsafe.As<nuint, VolatileUIntPtr>(ref location).Value = value;
222Unsafe.As<T>(Unsafe.As<T, VolatileObject>(ref Unsafe.AsRef(in location)).Value)!;
227Unsafe.As<T, VolatileObject>(ref location).Value = value;
src\libraries\System.Private.CoreLib\src\System\UInt128.cs (13)
851sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - Size);
854result = Unsafe.ReadUnaligned<UInt128>(ref sourceRef);
870result |= Unsafe.Add(ref sourceRef, i);
909result = Unsafe.ReadUnaligned<UInt128>(ref sourceRef);
926UInt128 part = Unsafe.Add(ref sourceRef, i);
1144Unsafe.WriteUnaligned(ref *(byte*)(pLeft + 0), (uint)(quotient._lower >> 00));
1145Unsafe.WriteUnaligned(ref *(byte*)(pLeft + 1), (uint)(quotient._lower >> 32));
1147Unsafe.WriteUnaligned(ref *(byte*)(pLeft + 2), (uint)(quotient._upper >> 00));
1148Unsafe.WriteUnaligned(ref *(byte*)(pLeft + 3), (uint)(quotient._upper >> 32));
1156Unsafe.WriteUnaligned(ref *(byte*)(pRight + 0), (uint)(divisor._lower >> 00));
1157Unsafe.WriteUnaligned(ref *(byte*)(pRight + 1), (uint)(divisor._lower >> 32));
1159Unsafe.WriteUnaligned(ref *(byte*)(pRight + 2), (uint)(divisor._upper >> 00));
1160Unsafe.WriteUnaligned(ref *(byte*)(pRight + 3), (uint)(divisor._upper >> 32));
src\libraries\System.Private.CoreLib\src\System\UIntPtr.cs (23)
241Unsafe.SkipInit(out result);
242return nuint_t.TryParse(s, out Unsafe.As<nuint, nuint_t>(ref result));
252Unsafe.SkipInit(out result);
253return nuint_t.TryParse(s, provider, out Unsafe.As<nuint, nuint_t>(ref result));
258Unsafe.SkipInit(out result);
259return nuint_t.TryParse(s, style, provider, out Unsafe.As<nuint, nuint_t>(ref result));
264Unsafe.SkipInit(out result);
265return nuint_t.TryParse(s, out Unsafe.As<nuint, nuint_t>(ref result));
274Unsafe.SkipInit(out result);
275return nuint_t.TryParse(utf8Text, out Unsafe.As<nuint, nuint_t>(ref result));
281Unsafe.SkipInit(out result);
282return nuint_t.TryParse(s, provider, out Unsafe.As<nuint, nuint_t>(ref result));
287Unsafe.SkipInit(out result);
288return nuint_t.TryParse(s, style, provider, out Unsafe.As<nuint, nuint_t>(ref result));
364sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(nuint_t));
367result = Unsafe.ReadUnaligned<nuint>(ref sourceRef);
383result |= Unsafe.Add(ref sourceRef, i);
422result = Unsafe.ReadUnaligned<nuint>(ref sourceRef);
439nuint part = Unsafe.Add(ref sourceRef, i);
1229Unsafe.SkipInit(out result);
1230return nuint_t.TryParse(utf8Text, style, provider, out Unsafe.As<nuint, nuint_t>(ref result));
1239Unsafe.SkipInit(out result);
1240return nuint_t.TryParse(utf8Text, provider, out Unsafe.As<nuint, nuint_t>(ref result));
src\System\Array.CoreCLR.cs (20)
165ref byte offsetDataRef = ref Unsafe.Add(ref arrayDataRef, flattenedIndex * pMethodTable->ComponentSize);
173ref object elementRef = ref Unsafe.As<byte, object>(ref arrayDataRef);
174ref object offsetElementRef = ref Unsafe.Add(ref elementRef, (nuint)flattenedIndex);
207ref byte offsetDataRef = ref Unsafe.Add(ref arrayDataRef, flattenedIndex * pMethodTable->ComponentSize);
211SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, nint>(ref offsetDataRef), elementSize / (nuint)sizeof(IntPtr));
221Unsafe.Add(ref Unsafe.As<byte, object?>(ref arrayDataRef), (nuint)flattenedIndex) = null;
230Unsafe.Add(ref Unsafe.As<byte, object?>(ref arrayDataRef), (nuint)flattenedIndex) = value;
236ref byte offsetDataRef = ref Unsafe.Add(ref arrayDataRef, flattenedIndex * pMethodTable->ComponentSize);
288public int Length => checked((int)Unsafe.As<RawArrayData>(this).Length);
291internal nuint NativeLength => Unsafe.As<RawArrayData>(this).Length;
344arrayRef = ref Unsafe.Add(ref arrayRef, elementSize);
404T[] @this = Unsafe.As<T[]>(this);
414T[] @this = Unsafe.As<T[]>(this);
422T[] @this = Unsafe.As<T[]>(this);
430T[] @this = Unsafe.As<T[]>(this);
443T[] @this = Unsafe.As<T[]>(this);
462T[] @this = Unsafe.As<T[]>(this);
483T[] @this = Unsafe.As<T[]>(this);
src\System\Runtime\CompilerServices\AsyncHelpers.CoreCLR.cs (11)
127return Unsafe.As<byte, object>(ref Unsafe.Add(ref data, DataOffset + contIndex * PointerSize));
135Unsafe.As<byte, Exception>(ref Unsafe.Add(ref data, DataOffset + contIndex * PointerSize)) = ex;
141return ref Unsafe.NullRef<byte>();
145return ref Unsafe.Add(ref data, DataOffset + contIndex * PointerSize);
256Unsafe.As<byte, object?>(ref Unsafe.Add(ref RuntimeHelpers.GetRawData(newContinuation), keepAliveOffset)) = loaderAllocator;
269Unsafe.As<byte, object?>(ref Unsafe.Add(ref RuntimeHelpers.GetRawData(newContinuation), keepAliveOffset)) = GCHandle.FromIntPtr(loaderAllocatorHandle).Target;
530private ref byte GetResultStorage() => ref Unsafe.As<T?, byte>(ref m_result);
src\System\Runtime\CompilerServices\RuntimeHelpers.CoreCLR.cs (19)
69new ReadOnlySpan<ushort>(ref Unsafe.As<byte, ushort>(ref src), array.Length),
70new Span<ushort>(ref Unsafe.As<byte, ushort>(ref dst), array.Length));
74new ReadOnlySpan<uint>(ref Unsafe.As<byte, uint>(ref src), array.Length),
75new Span<uint>(ref Unsafe.As<byte, uint>(ref dst), array.Length));
79new ReadOnlySpan<ulong>(ref Unsafe.As<byte, ulong>(ref src), array.Length),
80new Span<ulong>(ref Unsafe.As<byte, ulong>(ref dst), array.Length));
392ref Unsafe.As<RawData>(obj).Data;
402rawSize += (uint)Unsafe.As<RawArrayData>(obj).Length * (nuint)pMT->ComponentSize;
423return ref Unsafe.As<byte, int>(ref Unsafe.As<RawArrayData>(array).Data);
630/// This API returns the same value as <see cref="Unsafe.SizeOf{T}"/> for the type that <paramref name="type"/> represents.
685private MethodDescChunk* GetMethodDescChunk() => (MethodDescChunk*)(((byte*)Unsafe.AsPointer<MethodDesc>(ref this)) - (sizeof(MethodDescChunk) + ChunkIndex * sizeof(IntPtr)));
1021return *(RuntimeType*)Unsafe.AsPointer(ref _exposedClassObject);
1051return ref Unsafe.AsRef<byte>((byte*)((nuint)p & ~(nuint)DynamicStaticsInfo.ISCLASSNOTINITED));
1128return *(RuntimeType*)Unsafe.AsPointer(ref ExposedClassObjectRaw);
1141return ref Unsafe.Subtract(ref Unsafe.As<MethodTableAuxiliaryData, DynamicStaticsInfo>(ref this), 1);
1149return ref Unsafe.Subtract(ref Unsafe.As<MethodTableAuxiliaryData, ThreadStaticsInfo>(ref this), 1);
src\System\Runtime\InteropServices\Marshal.CoreCLR.cs (5)
263structMarshalStub(ref structure.GetRawData(), (byte*)ptr, MarshalOperation.Cleanup, ref Unsafe.NullRef<CleanupWorkListElement?>());
266structMarshalStub(ref structure.GetRawData(), (byte*)ptr, MarshalOperation.Marshal, ref Unsafe.NullRef<CleanupWorkListElement?>());
291structMarshalStub(ref structure.GetRawData(), (byte*)ptr, MarshalOperation.Unmarshal, ref Unsafe.NullRef<CleanupWorkListElement?>());
325structMarshalStub(ref Unsafe.NullRef<byte>(), (byte*)ptr, MarshalOperation.Cleanup, ref Unsafe.NullRef<CleanupWorkListElement?>());
src\System\ValueType.cs (8)
126hashCode.Add(Unsafe.As<byte, object>(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode());
130hashCode.Add(Unsafe.As<byte, double>(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode());
134hashCode.Add(Unsafe.As<byte, float>(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode());
139hashCode.AddBytes(MemoryMarshal.CreateReadOnlySpan(ref Unsafe.AddByteOffset(ref rawData, fieldOffset), (int)fieldSize));
145hashCode.Add(RuntimeHelpers.Box(fieldMT, ref Unsafe.AddByteOffset(ref rawData, fieldOffset))?.GetHashCode() ?? 0);
src\Workspaces\SharedUtilitiesAndExtensions\Compiler\Core\Utilities\Base64Utilities.cs (24)
48Unsafe.Add(ref destination, 1) = (byte)(value >> 8);
49Unsafe.Add(ref destination, 2) = (byte)value;
56int i1 = Unsafe.Add(ref encodedChars, 1);
57int i2 = Unsafe.Add(ref encodedChars, 2);
58int i3 = Unsafe.Add(ref encodedChars, 3);
63i0 = Unsafe.Add(ref decodingMap, i0);
64i1 = Unsafe.Add(ref decodingMap, i1);
65i2 = Unsafe.Add(ref decodingMap, i2);
66i3 = Unsafe.Add(ref decodingMap, i3);
227int result = Decode(ref Unsafe.Add(ref srcChars, sourceIndex), ref decodingMap);
230WriteThreeLowOrderBytes(ref Unsafe.Add(ref destBytes, destIndex), result);
245int i0 = Unsafe.Add(ref srcChars, srcLength - 4);
246int i1 = Unsafe.Add(ref srcChars, srcLength - 3);
247int i2 = Unsafe.Add(ref srcChars, srcLength - 2);
248int i3 = Unsafe.Add(ref srcChars, srcLength - 1);
252i0 = Unsafe.Add(ref decodingMap, i0);
253i1 = Unsafe.Add(ref decodingMap, i1);
262i2 = Unsafe.Add(ref decodingMap, i2);
263i3 = Unsafe.Add(ref decodingMap, i3);
274WriteThreeLowOrderBytes(ref Unsafe.Add(ref destBytes, destIndex), i0);
279i2 = Unsafe.Add(ref decodingMap, i2);
289Unsafe.Add(ref destBytes, destIndex) = (byte)(i0 >> 16);
290Unsafe.Add(ref destBytes, destIndex + 1) = (byte)(i0 >> 8);
299Unsafe.Add(ref destBytes, destIndex) = (byte)(i0 >> 16);