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)
54Memmove(ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(dst), uDstOffset), ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(src), uSrcOffset), uCount);
86return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index);
97Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index) = value;
138ref Unsafe.As<T, byte>(ref destination),
139ref Unsafe.As<T, byte>(ref source),
146ref Unsafe.As<T, byte>(ref destination),
147ref Unsafe.As<T, byte>(ref source),
178if (Unsafe.AreSame(ref source, ref destination))
182if ((nuint)(nint)Unsafe.ByteOffset(ref source, ref destination) >= byteCount)
190destination = ref Unsafe.AddByteOffset(ref destination, BulkMoveWithWriteBarrierChunk);
191source = ref Unsafe.AddByteOffset(ref source, BulkMoveWithWriteBarrierChunk);
201BulkMoveWithWriteBarrierInternal(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)
182int i2 = Unsafe.Add(ref decodingMap, (IntPtr)t2);
183int i3 = Unsafe.Add(ref decodingMap, (IntPtr)t3);
205int i2 = Unsafe.Add(ref decodingMap, (IntPtr)t2);
403int i0 = Unsafe.Add(ref decodingMap, (int)t0);
404int i1 = Unsafe.Add(ref decodingMap, (int)t1);
413int i2 = Unsafe.Add(ref decodingMap, (int)t2);
414int i3 = Unsafe.Add(ref decodingMap, (int)t3);
431int i2 = Unsafe.Add(ref decodingMap, (int)t2);
688if (decoder.IsValidPadding(Unsafe.Subtract(ref ptrToLastElement, 1)))
707if (decoder.IsValidPadding(Unsafe.Subtract(ref ptrToLastElement, 1)))
1527int i0 = Unsafe.Add(ref decodingMap, (int)t0);
1528int i1 = Unsafe.Add(ref decodingMap, (int)t1);
1529int i2 = Unsafe.Add(ref decodingMap, (int)t2);
1530int i3 = Unsafe.Add(ref decodingMap, (int)t3);
1571int i0 = Unsafe.Add(ref decodingMap, (IntPtr)t0);
1572int i1 = Unsafe.Add(ref decodingMap, (IntPtr)t1);
1738int i0 = Unsafe.Add(ref decodingMap, (int)t0);
1739int i1 = Unsafe.Add(ref decodingMap, (int)t1);
1740int i2 = Unsafe.Add(ref decodingMap, (int)t2);
1741int i3 = Unsafe.Add(ref decodingMap, (int)t3);
1787int i0 = Unsafe.Add(ref decodingMap, (IntPtr)t0);
1788int i1 = Unsafe.Add(ref decodingMap, (IntPtr)t1);
src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64EncoderHelper.cs (24)
622Unsafe.WriteUnaligned(bufferBytes + destinationIndex, result);
641uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
642uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
643uint i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
644uint i3 = Unsafe.Add(ref encodingMap, (IntPtr)(i & 0x3F));
669uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 10));
670uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 4) & 0x3F));
683Unsafe.WriteUnaligned(dest, result);
694ushort i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
695ushort i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
696ushort i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
739uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 10));
740uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 4) & 0x3F));
743Unsafe.WriteUnaligned(dest, result);
754uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
755uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
756uint i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
759Unsafe.WriteUnaligned(dest, result);
799Unsafe.WriteUnaligned(destination, result);
893ulong i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18));
894ulong i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F));
895ulong i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F));
896ulong i3 = Unsafe.Add(ref encodingMap, (IntPtr)(i & 0x3F));
908Unsafe.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);
929return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(new ReadOnlySpan<char>(chArr, 0, newLength));
935ReadOnlySpan<byte> srcUtf8Span = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(str);
988return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(destUtf8Span.Slice(0, newLength));
1077ref int r = ref Unsafe.AsRef(in _a);
1078return r ^ Unsafe.Add(ref r, 1) ^ Unsafe.Add(ref r, 2) ^ Unsafe.Add(ref r, 3);
1092return Unsafe.BitCast<Guid, Vector128<byte>>(left) == Unsafe.BitCast<Guid, Vector128<byte>>(right);
1095ref int rA = ref Unsafe.AsRef(in left._a);
1096ref int rB = ref Unsafe.AsRef(in right._a);
1101&& Unsafe.Add(ref rA, 1) == Unsafe.Add(ref rB, 1)
1102&& Unsafe.Add(ref rA, 2) == Unsafe.Add(ref rB, 2)
1103&& Unsafe.Add(ref rA, 3) == Unsafe.Add(ref rB, 3);
1528Vector128<byte> srcVec = Unsafe.BitCast<Guid, Vector128<byte>>(value);
src\libraries\System.Private.CoreLib\src\System\IntPtr.cs (18)
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));
1431Unsafe.SkipInit(out result);
1432return nint_t.TryParse(utf8Text, style, provider, out Unsafe.As<nint, nint_t>(ref result));
1441Unsafe.SkipInit(out result);
1442return nint_t.TryParse(utf8Text, provider, out Unsafe.As<nint, nint_t>(ref result));
src\libraries\System.Private.CoreLib\src\System\Marvin.OrdinalIgnoreCase.cs (6)
29tempValue = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref data, byteOffset)));
46tempValue = Unsafe.AddByteOffset(ref data, byteOffset);
79return ComputeHash32OrdinalIgnoreCaseSlow(ref Unsafe.AddByteOffset(ref data, byteOffset), (int)ucount, p0, p1);
94int 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)
878if (source.TryCopyTo(Unsafe.BitCast<Span<TChar>, Span<char>>(destination)))
889return Encoding.UTF8.TryGetBytes(source, Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten);
1834Unsafe.CopyBlockUnaligned(
1836ref Unsafe.Add(ref GetTwoDigitsBytesRef(typeof(TChar) == typeof(char)), (uint)sizeof(TChar) * 2 * value),
1854Unsafe.CopyBlockUnaligned(
1856ref Unsafe.Add(ref charsArray, (uint)sizeof(TChar) * 2 * value),
1859Unsafe.CopyBlockUnaligned(
1861ref 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);
1456ReadOnlySpan<byte> bytes = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(value);
src\libraries\System.Private.CoreLib\src\System\Numerics\Vector.cs (92)
123Unsafe.SkipInit(out Vector<T> result);
150Unsafe.SkipInit(out Vector<T> result);
231return Unsafe.BitCast<Vector<TFrom>, Vector<TTo>>(vector);
373Unsafe.SkipInit(out Vector<T> result);
393Unsafe.SkipInit(out Vector<double> result);
412Unsafe.SkipInit(out Vector<float> result);
519Unsafe.SkipInit(out Vector<int> result);
536Unsafe.SkipInit(out Vector<int> result);
553Unsafe.SkipInit(out Vector<long> result);
570Unsafe.SkipInit(out Vector<long> result);
587Unsafe.SkipInit(out Vector<float> result);
628Unsafe.SkipInit(out Vector<uint> result);
646Unsafe.SkipInit(out Vector<uint> result);
664Unsafe.SkipInit(out Vector<ulong> result);
682Unsafe.SkipInit(out Vector<ulong> result);
696Unsafe.SkipInit(out Vector<T> result);
754Unsafe.SkipInit(out Vector<T> result);
815Unsafe.SkipInit(out Vector<T> result);
838return Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
867Unsafe.SkipInit(out Vector<T> result);
885Unsafe.SkipInit(out Vector<T> result);
959Unsafe.SkipInit(out Vector<T> result);
1029Unsafe.SkipInit(out Vector<T> result);
1090Unsafe.SkipInit(out Vector<T> result);
1110Unsafe.SkipInit(out Vector<double> result);
1129Unsafe.SkipInit(out Vector<float> result);
1153Unsafe.SkipInit(out Vector<double> result);
1177Unsafe.SkipInit(out Vector<float> result);
1216Unsafe.SkipInit(out Vector<T> result);
1304Unsafe.SkipInit(out Vector<T> result);
1386Unsafe.SkipInit(out Vector<T> result);
1713Unsafe.SkipInit(out Vector<T> result);
1771Unsafe.SkipInit(out Vector<T> result);
1859Unsafe.SkipInit(out Vector<T> result);
1987ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
1988return Unsafe.ReadUnaligned<Vector<T>>(in address);
2003ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2004return Unsafe.ReadUnaligned<Vector<T>>(in address);
2010Unsafe.SkipInit(out Vector<T> result);
2052Unsafe.SkipInit(out Vector<T> result);
2102Unsafe.SkipInit(out Vector<T> result);
2125Unsafe.SkipInit(out Vector<T> result);
2148Unsafe.SkipInit(out Vector<T> result);
2171Unsafe.SkipInit(out Vector<T> result);
2194Unsafe.SkipInit(out Vector<T> result);
2217Unsafe.SkipInit(out Vector<T> result);
2240Unsafe.SkipInit(out Vector<T> result);
2263Unsafe.SkipInit(out Vector<T> result);
2286Unsafe.SkipInit(out Vector<T> result);
2309Unsafe.SkipInit(out Vector<T> result);
2349Unsafe.SkipInit(out Vector<T> result);
2365Unsafe.SkipInit(out Vector<double> result);
2381Unsafe.SkipInit(out Vector<float> result);
2398Unsafe.SkipInit(out Vector<TResult> result);
2467Unsafe.SkipInit(out Vector<TResult> result);
2571Unsafe.SkipInit(out Vector<T> result);
2629Unsafe.SkipInit(out Vector<T> result);
2882Unsafe.SkipInit(out Vector<T> result);
2924Unsafe.SkipInit(out Vector<T> sinResult);
2925Unsafe.SkipInit(out Vector<T> cosResult);
2973Unsafe.SkipInit(out Vector<T> result);
3033ref byte address = ref Unsafe.As<T, byte>(ref destination);
3034Unsafe.WriteUnaligned(ref address, source);
3049destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
3050Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
3068Unsafe.SkipInit(out Vector<T> result);
3128Unsafe.SkipInit(out Vector<T> result);
3279Unsafe.SkipInit(out Vector<ushort> lower);
3297Unsafe.SkipInit(out Vector<int> lower);
3315Unsafe.SkipInit(out Vector<long> lower);
3334Unsafe.SkipInit(out Vector<short> lower);
3352Unsafe.SkipInit(out Vector<double> lower);
3371Unsafe.SkipInit(out Vector<uint> lower);
3390Unsafe.SkipInit(out Vector<ulong> lower);
3409Unsafe.SkipInit(out Vector<ushort> upper);
3427Unsafe.SkipInit(out Vector<int> upper);
3445Unsafe.SkipInit(out Vector<long> upper);
3464Unsafe.SkipInit(out Vector<short> upper);
3482Unsafe.SkipInit(out Vector<double> upper);
3501Unsafe.SkipInit(out Vector<uint> upper);
3520Unsafe.SkipInit(out Vector<ulong> upper);
3564ref T address = ref Unsafe.As<Vector<T>, T>(ref Unsafe.AsRef(in vector));
3565return Unsafe.Add(ref address, index);
3572ref T address = ref Unsafe.As<Vector<T>, T>(ref Unsafe.AsRef(in vector));
3573Unsafe.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)
84_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */);
120_reference = ref Unsafe.AsRef(in reference);
151return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */);
228return new ReadOnlySpan<T>(ref Unsafe.As<TDerived, T>(ref items._reference), items.Length);
293ref T ret = ref Unsafe.NullRef<T>();
349Unsafe.AreSame(ref left._reference, ref right._reference);
359return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length));
377return new ReadOnlySpan<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start);
400return 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)
38ref Unsafe.As<T, byte>(ref GetReference(span)),
61ref Unsafe.As<T, byte>(ref GetReference(span)),
94internal 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);
101internal 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);
155ref Unsafe.As<TFrom, TTo>(ref span._reference),
210ref Unsafe.As<TFrom, TTo>(ref GetReference(span)),
229new Span<T>(ref Unsafe.AsRef(in reference), length);
246new ReadOnlySpan<T>(ref Unsafe.AsRef(in reference), length);
292segment = new ArraySegment<T>(Unsafe.As<T[]>(obj), index & ReadOnlyMemory<T>.RemoveFlagsBitMask, length);
301if (Unsafe.As<MemoryManager<T>>(obj).TryGetArray(out ArraySegment<T> tempArraySegment))
413T[] array = Unsafe.As<T[]>(obj);
481return Unsafe.ReadUnaligned<T>(ref GetReference(source));
501value = Unsafe.ReadUnaligned<T>(ref GetReference(source));
520Unsafe.WriteUnaligned(ref GetReference(destination), value);
539Unsafe.WriteUnaligned(ref GetReference(destination), value);
563return ref Unsafe.As<byte, T>(ref GetReference(span));
585return 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)
268return Unsafe.BitCast<Vector128<TFrom>, Vector128<TTo>>(vector);
652Unsafe.SkipInit(out Vector128<float> result);
763Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
790Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
807Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
1038return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref values[0]));
1059return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref values[index]));
1076return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
1303Unsafe.SkipInit(out Vector128<T> result);
1489Unsafe.SkipInit(out Vector128<T> result);
2406ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
2407return Unsafe.ReadUnaligned<Vector128<T>>(in address);
2422ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2423return Unsafe.ReadUnaligned<Vector128<T>>(in address);
2429internal static Vector128<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source));
2435internal static Vector128<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset);
2750Unsafe.SkipInit(out Vector128<TResult> result);
2847Unsafe.SkipInit(out Vector128<TResult> result);
3367Unsafe.SkipInit(out Vector128<byte> result);
3412Unsafe.SkipInit(out Vector128<sbyte> result);
3489Unsafe.SkipInit(out Vector128<short> result);
3514Unsafe.SkipInit(out Vector128<ushort> result);
3577Unsafe.SkipInit(out Vector128<int> result);
3602Unsafe.SkipInit(out Vector128<uint> result);
3626Unsafe.SkipInit(out Vector128<float> result);
3708Unsafe.SkipInit(out Vector128<long> result);
3733Unsafe.SkipInit(out Vector128<ulong> result);
3757Unsafe.SkipInit(out Vector128<double> result);
3986ref byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref destination, elementOffset));
3987Unsafe.WriteUnaligned(ref address, source.AsDouble().ToScalar());
4000ref byte address = ref Unsafe.As<T, byte>(ref destination);
4001Unsafe.WriteUnaligned(ref address, source);
4016destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
4017Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
4112Unsafe.SkipInit(out Vector256<T> result);
4165Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
4562ref T address = ref Unsafe.As<Vector128<T>, T>(ref Unsafe.AsRef(in vector));
4563return Unsafe.Add(ref address, index);
4598ref T address = ref Unsafe.As<Vector128<T>, T>(ref Unsafe.AsRef(in vector));
4599Unsafe.Add(ref address, index) = value;
4603internal static void SetLowerUnsafe<T>(in this Vector128<T> vector, Vector64<T> value) => Unsafe.AsRef(in vector._lower) = value;
4606internal 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)
253return Unsafe.BitCast<Vector256<TFrom>, Vector256<TTo>>(vector);
370ref byte address = ref Unsafe.As<Vector<T>, byte>(ref value);
371return Unsafe.ReadUnaligned<Vector256<T>>(ref address);
376Unsafe.WriteUnaligned(ref Unsafe.As<Vector256<T>, byte>(ref result), value);
394ref byte address = ref Unsafe.As<Vector256<T>, byte>(ref value);
395return Unsafe.ReadUnaligned<Vector<T>>(ref address);
400Unsafe.WriteUnaligned(ref Unsafe.As<Vector<T>, byte>(ref result), value);
770Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
797Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
814Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
1039return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[0]));
1060return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref values[index]));
1077return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
1381Unsafe.SkipInit(out Vector256<T> result);
1569Unsafe.SkipInit(out Vector256<T> result);
2484ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
2485return Unsafe.ReadUnaligned<Vector256<T>>(in address);
2500ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2501return Unsafe.ReadUnaligned<Vector256<T>>(in address);
2507internal static Vector256<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source));
2513internal static Vector256<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset);
2828Unsafe.SkipInit(out Vector256<TResult> result);
2897Unsafe.SkipInit(out Vector256<TResult> result);
3376Unsafe.SkipInit(out Vector256<byte> result);
3401Unsafe.SkipInit(out Vector256<sbyte> result);
3466Unsafe.SkipInit(out Vector256<short> result);
3491Unsafe.SkipInit(out Vector256<ushort> result);
3554Unsafe.SkipInit(out Vector256<int> result);
3579Unsafe.SkipInit(out Vector256<uint> result);
3603Unsafe.SkipInit(out Vector256<float> result);
3685Unsafe.SkipInit(out Vector256<long> result);
3710Unsafe.SkipInit(out Vector256<ulong> result);
3734Unsafe.SkipInit(out Vector256<double> result);
3961ref byte address = ref Unsafe.As<T, byte>(ref destination);
3962Unsafe.WriteUnaligned(ref address, source);
3977destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
3978Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
4061Unsafe.SkipInit(out Vector512<T> result);
4114Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
4463ref T address = ref Unsafe.As<Vector256<T>, T>(ref Unsafe.AsRef(in vector));
4464return Unsafe.Add(ref address, index);
4512ref T address = ref Unsafe.As<Vector256<T>, T>(ref Unsafe.AsRef(in vector));
4513Unsafe.Add(ref address, index) = value;
4516internal static void SetLowerUnsafe<T>(in this Vector256<T> vector, Vector128<T> value) => Unsafe.AsRef(in vector._lower) = value;
4518internal 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)
252return Unsafe.BitCast<Vector512<TFrom>, Vector512<TTo>>(vector);
369Unsafe.WriteUnaligned(ref Unsafe.As<Vector512<T>, byte>(ref result), value);
385ref byte address = ref Unsafe.As<Vector512<T>, byte>(ref value);
386return Unsafe.ReadUnaligned<Vector<T>>(ref address);
682Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
708Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
724Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
934return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[0]));
954return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref values[index]));
971return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
1414Unsafe.SkipInit(out Vector512<T> result);
1601Unsafe.SkipInit(out Vector512<T> result);
2503ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
2504return Unsafe.ReadUnaligned<Vector512<T>>(in address);
2519ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2520return Unsafe.ReadUnaligned<Vector512<T>>(in address);
2526internal static Vector512<ushort> LoadUnsafe(ref char source) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source));
2532internal static Vector512<ushort> LoadUnsafe(ref char source, nuint elementOffset) => LoadUnsafe(ref Unsafe.As<char, ushort>(ref source), elementOffset);
2846Unsafe.SkipInit(out Vector512<TResult> result);
2915Unsafe.SkipInit(out Vector512<TResult> result);
3394Unsafe.SkipInit(out Vector512<byte> result);
3419Unsafe.SkipInit(out Vector512<sbyte> result);
3484Unsafe.SkipInit(out Vector512<short> result);
3509Unsafe.SkipInit(out Vector512<ushort> result);
3572Unsafe.SkipInit(out Vector512<int> result);
3597Unsafe.SkipInit(out Vector512<uint> result);
3621Unsafe.SkipInit(out Vector512<float> result);
3703Unsafe.SkipInit(out Vector512<long> result);
3728Unsafe.SkipInit(out Vector512<ulong> result);
3752Unsafe.SkipInit(out Vector512<double> result);
3965ref byte address = ref Unsafe.As<T, byte>(ref destination);
3966Unsafe.WriteUnaligned(ref address, source);
3981destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
3982Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
4084Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
4433ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector));
4434return Unsafe.Add(ref address, index);
4482ref T address = ref Unsafe.As<Vector512<T>, T>(ref Unsafe.AsRef(in vector));
4483Unsafe.Add(ref address, index) = value;
4486internal static void SetLowerUnsafe<T>(in this Vector512<T> vector, Vector256<T> value) => Unsafe.AsRef(in vector._lower) = value;
4488internal 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 (121)
126Unsafe.SkipInit(out Vector64<T> result);
153Unsafe.SkipInit(out Vector64<T> result);
253return Unsafe.BitCast<Vector64<TFrom>, Vector64<TTo>>(vector);
397Unsafe.SkipInit(out Vector64<T> result);
458Unsafe.SkipInit(out Vector64<double> result);
477Unsafe.SkipInit(out Vector64<double> result);
495Unsafe.SkipInit(out Vector64<int> result);
513Unsafe.SkipInit(out Vector64<int> result);
531Unsafe.SkipInit(out Vector64<long> result);
549Unsafe.SkipInit(out Vector64<long> result);
567Unsafe.SkipInit(out Vector64<float> result);
586Unsafe.SkipInit(out Vector64<float> result);
605Unsafe.SkipInit(out Vector64<uint> result);
624Unsafe.SkipInit(out Vector64<uint> result);
643Unsafe.SkipInit(out Vector64<ulong> result);
662Unsafe.SkipInit(out Vector64<ulong> result);
692Unsafe.SkipInit(out Vector64<T> result);
721Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[0]), vector);
748Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination[startIndex]), vector);
765Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
771Unsafe.SkipInit(out Vector64<T> result);
903Unsafe.SkipInit(out Vector64<T> result);
1013return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref values[0]));
1034return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref values[index]));
1051return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));
1069Unsafe.SkipInit(out Vector64<byte> result);
1092Unsafe.SkipInit(out Vector64<short> result);
1109Unsafe.SkipInit(out Vector64<int> result);
1131Unsafe.SkipInit(out Vector64<sbyte> result);
1151Unsafe.SkipInit(out Vector64<float> result);
1169Unsafe.SkipInit(out Vector64<ushort> result);
1187Unsafe.SkipInit(out Vector64<uint> result);
1297Unsafe.SkipInit(out Vector64<T> result);
1392Unsafe.SkipInit(out Vector64<T> result);
1473Unsafe.SkipInit(out Vector64<T> result);
1517Unsafe.SkipInit(out Vector64<T> result);
1610Unsafe.SkipInit(out Vector64<T> result);
1649Unsafe.SkipInit(out Vector64<double> result);
1673Unsafe.SkipInit(out Vector64<float> result);
1713Unsafe.SkipInit(out Vector64<T> result);
1776Unsafe.SkipInit(out Vector64<T> result);
1832Unsafe.SkipInit(out Vector64<T> result);
2160Unsafe.SkipInit(out Vector64<T> result);
2219Unsafe.SkipInit(out Vector64<T> result);
2282Unsafe.SkipInit(out Vector64<T> result);
2384ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.AsRef(in source));
2385return Unsafe.ReadUnaligned<Vector64<T>>(in address);
2400ref readonly byte address = ref Unsafe.As<T, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset));
2401return Unsafe.ReadUnaligned<Vector64<T>>(in address);
2407Unsafe.SkipInit(out Vector64<T> result);
2453Unsafe.SkipInit(out Vector64<T> result);
2507Unsafe.SkipInit(out Vector64<T> result);
2530Unsafe.SkipInit(out Vector64<T> result);
2553Unsafe.SkipInit(out Vector64<T> result);
2576Unsafe.SkipInit(out Vector64<T> result);
2599Unsafe.SkipInit(out Vector64<T> result);
2622Unsafe.SkipInit(out Vector64<T> result);
2645Unsafe.SkipInit(out Vector64<T> result);
2668Unsafe.SkipInit(out Vector64<T> result);
2691Unsafe.SkipInit(out Vector64<T> result);
2714Unsafe.SkipInit(out Vector64<T> result);
2757Unsafe.SkipInit(out Vector64<T> result);
2781Unsafe.SkipInit(out Vector64<double> result);
2805Unsafe.SkipInit(out Vector64<float> result);
2822Unsafe.SkipInit(out Vector64<TResult> result);
2891Unsafe.SkipInit(out Vector64<TResult> result);
3006Unsafe.SkipInit(out Vector64<T> result);
3070Unsafe.SkipInit(out Vector64<T> result);
3181Unsafe.SkipInit(out Vector64<uint> result);
3203Unsafe.SkipInit(out Vector64<ulong> result);
3394Unsafe.SkipInit(out Vector64<byte> result);
3419Unsafe.SkipInit(out Vector64<sbyte> result);
3484Unsafe.SkipInit(out Vector64<short> result);
3509Unsafe.SkipInit(out Vector64<ushort> result);
3572Unsafe.SkipInit(out Vector64<int> result);
3597Unsafe.SkipInit(out Vector64<uint> result);
3621Unsafe.SkipInit(out Vector64<float> result);
3699Unsafe.SkipInit(out Vector64<T> result);
3713Unsafe.SkipInit(out Vector64<T> result);
3766Unsafe.SkipInit(out Vector64<T> sinResult);
3767Unsafe.SkipInit(out Vector64<T> cosResult);
3827Unsafe.SkipInit(out Vector64<T> result);
3887ref byte address = ref Unsafe.As<T, byte>(ref destination);
3888Unsafe.WriteUnaligned(ref address, source);
3903destination = ref Unsafe.Add(ref destination, (nint)elementOffset);
3904Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref destination), source);
3922Unsafe.SkipInit(out Vector64<T> result);
3995Unsafe.SkipInit(out Vector128<T> result);
4019Unsafe.SkipInit(out Vector64<T> result);
4053Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);
4111Unsafe.SkipInit(out Vector64<ushort> lower);
4129Unsafe.SkipInit(out Vector64<int> lower);
4147Unsafe.SkipInit(out Vector64<long> lower);
4166Unsafe.SkipInit(out Vector64<short> lower);
4184Unsafe.SkipInit(out Vector64<double> lower);
4203Unsafe.SkipInit(out Vector64<uint> lower);
4222Unsafe.SkipInit(out Vector64<ulong> lower);
4241Unsafe.SkipInit(out Vector64<ushort> upper);
4259Unsafe.SkipInit(out Vector64<int> upper);
4277Unsafe.SkipInit(out Vector64<long> upper);
4296Unsafe.SkipInit(out Vector64<short> upper);
4314Unsafe.SkipInit(out Vector64<double> upper);
4333Unsafe.SkipInit(out Vector64<uint> upper);
4352Unsafe.SkipInit(out Vector64<ulong> upper);
4458ref T address = ref Unsafe.As<Vector64<T>, T>(ref Unsafe.AsRef(in vector));
4459return Unsafe.Add(ref address, index);
4494ref T address = ref Unsafe.As<Vector64<T>, T>(ref Unsafe.AsRef(in vector));
4495Unsafe.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 (115)
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);
3127TVectorDouble s1 = Unsafe.BitCast<TVectorUInt64, TVectorDouble>(Unsafe.BitCast<TVectorDouble, TVectorUInt64>(s) & TVectorUInt64.Create(0xFFFFFFFF00000000));
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)
194TryIndexOfAny<DontNegate>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, asciiValues, out index);
198TryIndexOfAny<Negate>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, asciiValues, out index);
202TryLastIndexOfAny<DontNegate>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, asciiValues, out index);
206TryLastIndexOfAny<Negate>(ref Unsafe.As<char, short>(ref searchSpace), searchSpaceLength, asciiValues, out index);
296ref short searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
298while (!Unsafe.AreSame(ref currentSearchSpace, ref searchSpaceEnd))
306currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 1);
326ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - (2 * Vector256<short>.Count));
339currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector256<short>.Count);
341while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
348ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<short>.Count);
350ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
379ref short twoVectorsAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - (2 * Vector128<short>.Count));
392currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 2 * Vector128<short>.Count);
394while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref twoVectorsAwayFromEnd));
401ref short oneVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<short>.Count);
403ref short firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAwayFromEnd)
432char c = (char)Unsafe.Add(ref searchSpace, i);
442ref short currentSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
458ref short twoVectorsAfterStart = ref Unsafe.Add(ref searchSpace, 2 * Vector256<short>.Count);
462currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, 2 * Vector256<short>.Count);
473while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref twoVectorsAfterStart));
480ref short oneVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<short>.Count);
482ref short secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAfterStart)
483? ref Unsafe.Subtract(ref currentSearchSpace, Vector256<short>.Count)
509ref short twoVectorsAfterStart = ref Unsafe.Add(ref searchSpace, 2 * Vector128<short>.Count);
513currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, 2 * Vector128<short>.Count);
524while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref twoVectorsAfterStart));
531ref short oneVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<short>.Count);
533ref short secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref oneVectorAfterStart)
534? ref Unsafe.Subtract(ref currentSearchSpace, Vector128<short>.Count)
581ref byte searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
583while (!Unsafe.AreSame(ref currentSearchSpace, ref searchSpaceEnd))
591currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 1);
609ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<byte>.Count);
621currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<byte>.Count);
623while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref vectorAwayFromEnd));
630ref byte halfVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<byte>.Count);
632ref byte firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAwayFromEnd)
658ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<byte>.Count);
670currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<byte>.Count);
672while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref vectorAwayFromEnd));
679ref byte halfVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - sizeof(ulong));
681ref byte firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAwayFromEnd)
685ulong source0 = Unsafe.ReadUnaligned<ulong>(ref firstVector);
686ulong source1 = Unsafe.ReadUnaligned<ulong>(ref halfVectorAwayFromEnd);
710byte b = Unsafe.Add(ref searchSpace, i);
720ref byte currentSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
734ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count);
738currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector256<byte>.Count);
748while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref vectorAfterStart));
755ref byte halfVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<byte>.Count);
757ref byte secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAfterStart)
758? ref Unsafe.Subtract(ref currentSearchSpace, Vector128<byte>.Count)
783ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<byte>.Count);
787currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector128<byte>.Count);
797while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref vectorAfterStart));
804ref byte halfVectorAfterStart = ref Unsafe.Add(ref searchSpace, sizeof(ulong));
806ref byte secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAfterStart)
807? ref Unsafe.Subtract(ref currentSearchSpace, sizeof(ulong))
810ulong source0 = Unsafe.ReadUnaligned<ulong>(ref searchSpace);
811ulong source1 = Unsafe.ReadUnaligned<ulong>(ref secondVector);
852ref byte searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
854while (!Unsafe.AreSame(ref currentSearchSpace, ref searchSpaceEnd))
862currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, 1);
881ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector256<byte>.Count);
893currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector256<byte>.Count);
895while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref vectorAwayFromEnd));
902ref byte halfVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<byte>.Count);
904ref byte firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAwayFromEnd)
933ref byte vectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - Vector128<byte>.Count);
945currentSearchSpace = ref Unsafe.Add(ref currentSearchSpace, Vector128<byte>.Count);
947while (Unsafe.IsAddressLessThan(ref currentSearchSpace, ref vectorAwayFromEnd));
954ref byte halfVectorAwayFromEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength - sizeof(ulong));
956ref byte firstVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAwayFromEnd)
960ulong source0 = Unsafe.ReadUnaligned<ulong>(ref firstVector);
961ulong source1 = Unsafe.ReadUnaligned<ulong>(ref halfVectorAwayFromEnd);
984byte b = Unsafe.Add(ref searchSpace, i);
994ref byte currentSearchSpace = ref Unsafe.Add(ref searchSpace, searchSpaceLength);
1009ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector256<byte>.Count);
1013currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector256<byte>.Count);
1023while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref vectorAfterStart));
1030ref byte halfVectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<byte>.Count);
1032ref byte secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAfterStart)
1033? ref Unsafe.Subtract(ref currentSearchSpace, Vector128<byte>.Count)
1061ref byte vectorAfterStart = ref Unsafe.Add(ref searchSpace, Vector128<byte>.Count);
1065currentSearchSpace = ref Unsafe.Subtract(ref currentSearchSpace, Vector128<byte>.Count);
1075while (Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref vectorAfterStart));
1082ref byte halfVectorAfterStart = ref Unsafe.Add(ref searchSpace, sizeof(ulong));
1084ref byte secondVector = ref Unsafe.IsAddressGreaterThan(ref currentSearchSpace, ref halfVectorAfterStart)
1085? ref Unsafe.Subtract(ref currentSearchSpace, sizeof(ulong))
1088ulong source0 = Unsafe.ReadUnaligned<ulong>(ref searchSpace);
1089ulong 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));
1286return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
1307return offsetInVector - Vector256<short>.Count + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref secondVector) / (nuint)sizeof(T));
1489return (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
1496return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
1509return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current) / (nuint)sizeof(T));
1523return offsetInVector + (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref current0) / (nuint)sizeof(T));
1543return 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)
89_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */);
156return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */);
286ref T ret = ref Unsafe.NullRef<T>();
299SpanHelpers.ClearWithReferences(ref Unsafe.As<T, IntPtr>(ref _reference), (uint)_length * (nuint)(sizeof(T) / sizeof(nuint)));
303SpanHelpers.ClearWithoutReferences(ref Unsafe.As<T, byte>(ref _reference), (uint)_length * (nuint)sizeof(T));
367Unsafe.AreSame(ref left._reference, ref right._reference);
383return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length));
401return new Span<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start);
429return 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)
41if ((nuint)Unsafe.ByteOffset(ref src, ref dest) < len ||
42(nuint)Unsafe.ByteOffset(ref dest, ref src) < len)
47ref byte srcEnd = ref Unsafe.Add(ref src, len);
48ref byte destEnd = ref Unsafe.Add(ref dest, len);
59Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<Block16>(ref src));
72Unsafe.WriteUnaligned(ref Unsafe.Add(ref dest, 16), Unsafe.ReadUnaligned<Block16>(ref Unsafe.Add(ref src, 16)));
85Unsafe.WriteUnaligned(ref Unsafe.Add(ref dest, 32), Unsafe.ReadUnaligned<Block16>(ref Unsafe.Add(ref src, 32)));
100Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -16), Unsafe.ReadUnaligned<Block16>(ref Unsafe.Add(ref srcEnd, -16)));
118Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<long>(ref src));
119Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -8), Unsafe.ReadUnaligned<long>(ref Unsafe.Add(ref srcEnd, -8)));
133Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<int>(ref src));
134Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -4), Unsafe.ReadUnaligned<int>(ref Unsafe.Add(ref srcEnd, -4)));
145Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -2), Unsafe.ReadUnaligned<short>(ref Unsafe.Add(ref srcEnd, -2)));
163nuint misalignedElements = 64 - Unsafe.OpportunisticMisalignment(ref dest, 64);
164Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<Block64>(ref src));
165src = ref Unsafe.Add(ref src, misalignedElements);
166dest = ref Unsafe.Add(ref dest, misalignedElements);
178Unsafe.WriteUnaligned(ref dest, Unsafe.ReadUnaligned<Block64>(ref src));
206dest = ref Unsafe.Add(ref dest, 64);
207src = ref Unsafe.Add(ref src, 64);
216Unsafe.WriteUnaligned(ref Unsafe.Add(ref destEnd, -16), Unsafe.ReadUnaligned<Block16>(ref Unsafe.Add(ref srcEnd, -16)));
231if (Unsafe.AreSame(ref dest, ref src))
234_ = Unsafe.ReadUnaligned<byte>(ref dest);
241_ = Unsafe.ReadUnaligned<byte>(ref dest);
242_ = Unsafe.ReadUnaligned<byte>(ref src);
275ref byte destEnd = ref Unsafe.Add(ref dest, len);
286Unsafe.WriteUnaligned<Block16>(ref dest, default);
299Unsafe.WriteUnaligned<Block16>(ref Unsafe.Add(ref dest, 16), default);
312Unsafe.WriteUnaligned<Block16>(ref Unsafe.Add(ref dest, 32), default);
327Unsafe.WriteUnaligned<Block16>(ref Unsafe.Add(ref destEnd, -16), default);
345Unsafe.WriteUnaligned<long>(ref dest, 0);
346Unsafe.WriteUnaligned<long>(ref Unsafe.Add(ref destEnd, -8), 0);
360Unsafe.WriteUnaligned<int>(ref dest, 0);
361Unsafe.WriteUnaligned<int>(ref Unsafe.Add(ref destEnd, -4), 0);
372Unsafe.WriteUnaligned<short>(ref Unsafe.Add(ref destEnd, -2), 0);
387nuint misalignedElements = 64 - Unsafe.OpportunisticMisalignment(ref dest, 64);
388Unsafe.WriteUnaligned<Block64>(ref dest, default);
389dest = ref Unsafe.Add(ref dest, misalignedElements);
400Unsafe.WriteUnaligned<Block64>(ref dest, default);
428dest = ref Unsafe.Add(ref dest, 64);
437Unsafe.WriteUnaligned<Block16>(ref Unsafe.Add(ref destEnd, -16), default);
451_ = Unsafe.ReadUnaligned<byte>(ref dest);
468Unsafe.WriteUnaligned<Block16>(ptr, default);
469Unsafe.WriteUnaligned<Block16>(ptr + byteLength - 16, default);
513Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref dest, offset), vector);
514Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref dest, offset + (nuint)Vector<byte>.Count), vector);
526Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref dest, offset), vector);
535Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref dest, len - (nuint)Vector<byte>.Count), vector);
553Unsafe.Add(ref dest, (nint)i + 0) = value;
554Unsafe.Add(ref dest, (nint)i + 1) = value;
555Unsafe.Add(ref dest, (nint)i + 2) = value;
556Unsafe.Add(ref dest, (nint)i + 3) = value;
557Unsafe.Add(ref dest, (nint)i + 4) = value;
558Unsafe.Add(ref dest, (nint)i + 5) = value;
559Unsafe.Add(ref dest, (nint)i + 6) = value;
560Unsafe.Add(ref dest, (nint)i + 7) = value;
567Unsafe.Add(ref dest, (nint)i + 0) = value;
568Unsafe.Add(ref dest, (nint)i + 1) = value;
569Unsafe.Add(ref dest, (nint)i + 2) = value;
570Unsafe.Add(ref dest, (nint)i + 3) = value;
577Unsafe.Add(ref dest, (nint)i + 0) = value;
578Unsafe.Add(ref dest, (nint)i + 1) = value;
585Unsafe.Add(ref dest, (nint)i) = value;
src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Char.cs (75)
38ref byte valueTail = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref value, 1));
45int relativeIndex = NonPackedIndexOfChar(ref Unsafe.Add(ref searchSpace, offset), valueHead, remainingSearchSpaceLength);
57ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + 1)),
76ushort ch2Val = Unsafe.Add(ref value, valueTailLength);
79ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
123ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
124ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
143ushort ch2Val = Unsafe.Add(ref value, valueTailLength);
146ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
188ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
189ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
205ushort ch2Val = Unsafe.Add(ref value, valueTailLength);
208ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
250ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
251ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
275return LastIndexOfValueType(ref Unsafe.As<char, short>(ref searchSpace), (short)value, searchSpaceLength); // for single-char values use plain LastIndexOf
285ref byte valueTail = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref value, 1));
295int relativeIndex = LastIndexOfValueType(ref Unsafe.As<char, short>(ref searchSpace), (short)valueHead, remainingSearchSpaceLength);
301ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, relativeIndex + 1)),
320char ch2Val = Unsafe.Add(ref value, valueTailLength);
323ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
347ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
348ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
370char ch2Val = Unsafe.Add(ref value, valueTailLength);
373ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
397ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
398ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
420char ch2Val = Unsafe.Add(ref value, valueTailLength);
423ch2Val = Unsafe.Add(ref value, --ch1ch2Distance);
447ref Unsafe.As<char, byte>(ref Unsafe.Add(ref searchSpace, offset + charPos)),
448ref Unsafe.As<char, byte>(ref value), (nuint)(uint)valueLength * 2))
473if (Unsafe.AreSame(ref first, ref second))
486if (Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, (nint)i))) !=
487Unsafe.ReadUnaligned<Vector<ushort>>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, (nint)i))))
498if (Unsafe.ReadUnaligned<nuint>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, (nint)i))) !=
499Unsafe.ReadUnaligned<nuint>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, (nint)i))))
510if (Unsafe.ReadUnaligned<int>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref first, (nint)i))) ==
511Unsafe.ReadUnaligned<int>(ref Unsafe.As<char, byte>(ref Unsafe.Add(ref second, (nint)i))))
520int result = Unsafe.Add(ref first, (nint)i).CompareTo(Unsafe.Add(ref second, (nint)i));
900ref ushort first = ref Unsafe.As<char, ushort>(ref Unsafe.Add(ref buf, offset));
901ref ushort last = ref Unsafe.As<char, ushort>(ref Unsafe.Add(ref buf, lastOffset));
939ref byte first = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref buf, offset));
940ref byte last = ref Unsafe.As<char, byte>(ref Unsafe.Add(ref buf, lastOffset));
978ref ushort first = ref Unsafe.As<char, ushort>(ref Unsafe.Add(ref buf, offset));
979ref ushort last = ref Unsafe.As<char, ushort>(ref Unsafe.Add(ref buf, lastOffset));
1009ReverseInner(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),
711Buffer.Memmove(ref Unsafe.Add(ref result._firstChar, startIndex), ref value._firstChar, (nuint)insertLength);
712Buffer.Memmove(ref Unsafe.Add(ref result._firstChar, startIndex + insertLength), ref Unsafe.Add(ref _firstChar, startIndex), (nuint)(oldLength - startIndex));
948IEnumerator<char> en = Unsafe.As<IEnumerator<char>>(e);
1099ref char dest = ref Unsafe.Add(ref result._firstChar, copiedLength);
1136Buffer.Memmove(ref Unsafe.Add(ref result._firstChar, count), ref _firstChar, (nuint)oldLength);
1154new Span<char>(ref Unsafe.Add(ref result._firstChar, oldLength), count).Fill(paddingChar);
1175Buffer.Memmove(ref Unsafe.Add(ref result._firstChar, startIndex), ref Unsafe.Add(ref _firstChar, startIndex + count), (nuint)(newLength - startIndex));
1291ref ushort pSrc = ref Unsafe.Add(ref GetRawStringDataAsUInt16(), (uint)copyLength);
1292ref ushort pDst = ref Unsafe.Add(ref result.GetRawStringDataAsUInt16(), (uint)copyLength);
1301pSrc = ref Unsafe.Subtract(ref pSrc, adjust);
1302pDst = ref Unsafe.Subtract(ref pDst, adjust);
1308pSrc = ref Unsafe.Subtract(ref pSrc, adjust);
1309pDst = ref Unsafe.Subtract(ref pDst, adjust);
1315pSrc = ref Unsafe.Subtract(ref pSrc, adjust);
1316pDst = ref Unsafe.Subtract(ref pDst, adjust);
1355int pos = PackedSpanHelpers.IndexOf(ref Unsafe.Add(ref _firstChar, i), c, Length - i);
1368int pos = SpanHelpers.NonPackedIndexOfChar(ref Unsafe.Add(ref _firstChar, i), c, Length - i);
1384int pos = SpanHelpers.IndexOf(ref Unsafe.Add(ref _firstChar, i), Length - i, ref oldValue._firstChar, oldValue.Length);
2077ref uint charMap = ref Unsafe.As<ProbabilisticMap, uint>(ref map);
2192char curr = Unsafe.Add(ref source, offset);
2348source: 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)
267currentUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer);
268uint nextUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer + 4);
292currentUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer);
305currentUInt32 = Unsafe.ReadUnaligned<ushort>(pBuffer);
640ulong candidateUInt64 = Unsafe.ReadUnaligned<ulong>(pBuffer);
655currentDWord = Unsafe.ReadUnaligned<uint>(pBuffer);
656uint nextDWord = Unsafe.ReadUnaligned<uint>(pBuffer + 4);
680currentDWord = Unsafe.ReadUnaligned<uint>(pBuffer);
695currentDWord = Unsafe.ReadUnaligned<ushort>(pBuffer);
889currentUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer);
890uint nextUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer + 4 / sizeof(char));
914currentUInt32 = Unsafe.ReadUnaligned<uint>(pBuffer);
1196ulong candidateUInt64 = Unsafe.ReadUnaligned<ulong>(pBuffer);
1213currentDWord = Unsafe.ReadUnaligned<uint>(pBuffer);
1214uint nextDWord = Unsafe.ReadUnaligned<uint>(pBuffer + 4 / sizeof(char));
1238currentDWord = Unsafe.ReadUnaligned<uint>(pBuffer);
1281Unsafe.WriteUnaligned(ref outputBuffer, Sse2.ConvertToUInt32(vecNarrow));
1290Unsafe.WriteUnaligned(ref outputBuffer, lower.AsUInt32().ToScalar());
1299Unsafe.Add(ref outputBuffer, 1) = (byte)value;
1301Unsafe.Add(ref outputBuffer, 2) = (byte)value;
1303Unsafe.Add(ref outputBuffer, 3) = (byte)value;
1307Unsafe.Add(ref outputBuffer, 3) = (byte)value;
1309Unsafe.Add(ref outputBuffer, 2) = (byte)value;
1311Unsafe.Add(ref outputBuffer, 1) = (byte)value;
1331Unsafe.Add(ref outputBuffer, 1) = (byte)(value >> 16);
1335Unsafe.Add(ref outputBuffer, 1) = (byte)value;
1362utf16Data64Bits = Unsafe.ReadUnaligned<ulong>(pUtf16Buffer);
1370utf16Data32BitsHigh = Unsafe.ReadUnaligned<uint>(pUtf16Buffer);
1371utf16Data32BitsLow = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + 4 / sizeof(char));
1406utf16Data64Bits = Unsafe.ReadUnaligned<ulong>(pUtf16Buffer + currentOffset);
1416utf16Data32BitsHigh = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + currentOffset);
1417utf16Data32BitsLow = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + currentOffset + 4 / sizeof(char));
1435utf16Data32BitsHigh = Unsafe.ReadUnaligned<uint>(pUtf16Buffer + currentOffset);
2108asciiData = Unsafe.ReadUnaligned<uint>(pAsciiBuffer + currentOffset);
2123asciiData = Unsafe.ReadUnaligned<ushort>(pAsciiBuffer + currentOffset);
2287Unsafe.WriteUnaligned(ref Unsafe.As<char, byte>(ref outputBuffer), vecWide.ToScalar());
2293Unsafe.WriteUnaligned(ref Unsafe.As<char, byte>(ref outputBuffer), vecWide.ToScalar());
2302Unsafe.Add(ref outputBuffer, 1) = (char)(byte)value;
2304Unsafe.Add(ref outputBuffer, 2) = (char)(byte)value;
2306Unsafe.Add(ref outputBuffer, 3) = (char)value;
2310Unsafe.Add(ref outputBuffer, 3) = (char)(byte)value;
2312Unsafe.Add(ref outputBuffer, 2) = (char)(byte)value;
2314Unsafe.Add(ref outputBuffer, 1) = (char)(byte)value;
src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (12)
273pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
366pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
550pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
552pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
653pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
655pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
873pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
962pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
1153pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
1155pChars: (char*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(chars)),
1253pBytes: (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(bytes)),
1255pChars: (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),
835Append(ref Unsafe.Add(ref value.GetRawStringData(), startIndex), count);
1300Debug.Assert(!Unsafe.IsNullRef(ref separator));
2384ref char destination = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(chunkChars), chunkLength);
2390Unsafe.Add(ref destination, 1) = Unsafe.Add(ref value, 1);
2431new ReadOnlySpan<char>(ref Unsafe.Add(ref value, firstLength), restLength).CopyTo(m_ChunkChars);
2598value = 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)
70uint thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
97uint remainingInputBytes = (uint)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *pFinalPosWhereCanReadDWordFromInputBuffer) + 4;
105thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
106secondDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer + sizeof(uint));
246thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
290Unsafe.WriteUnaligned(pOutputBuffer, ExtractTwoCharsPackedFromTwoAdjacentTwoByteSequences(thisDWord));
301thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
390thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
413thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
488if (outputCharsRemaining > 1 && (nint)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *pFinalPosWhereCanReadDWordFromInputBuffer) >= 3)
497uint secondDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer + 3);
553thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
630Unsafe.WriteUnaligned(pOutputBuffer, ExtractCharsFromFourByteSequence(thisDWord));
641inputLength = (int)(void*)Unsafe.ByteOffset(ref *pInputBuffer, ref *pFinalPosWhereCanReadDWordFromInputBuffer) + 4;
906thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
934Unsafe.WriteUnaligned(pOutputBuffer, (ushort)valueToWrite);
958Unsafe.SkipInit(out nonAsciiUtf16DataMask);
960utf16Data = Unsafe.ReadUnaligned<Vector128<short>>(pInputBuffer);
1001possibleNonAsciiQWord = Unsafe.ReadUnaligned<ulong>(pInputBuffer);
1016Unsafe.WriteUnaligned(pOutputBuffer, Sse2.ConvertToUInt32(Sse2.PackUnsignedSaturate(utf16Data, utf16Data).AsUInt32()));
1059Unsafe.WriteUnaligned(pOutputBuffer, Sse2.ConvertToUInt32(Sse2.PackUnsignedSaturate(utf16Data, utf16Data).AsUInt32()));
1080Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(thisDWord | (thisDWord >> 8)));
1098thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1099secondDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer + 2);
1108Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(thisDWord | (thisDWord >> 8)));
1109Unsafe.WriteUnaligned(pOutputBuffer + 2, (ushort)(secondDWord | (secondDWord >> 8)));
1129Unsafe.WriteUnaligned(pOutputBuffer, (ushort)(thisDWord | (thisDWord >> 8)));
1175thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1197Unsafe.WriteUnaligned(pOutputBuffer, ExtractTwoUtf8TwoByteSequencesFromTwoPackedUtf16Chars(thisDWord));
1212thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1231Unsafe.WriteUnaligned(pOutputBuffer, (ushort)ExtractUtf8TwoByteSequenceFromFirstUtf16Char(thisDWord));
1272thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1311thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1369thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1389thisDWord = Unsafe.ReadUnaligned<uint>(pInputBuffer);
1403Unsafe.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\UIntPtr.cs (18)
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));
1223Unsafe.SkipInit(out result);
1224return nuint_t.TryParse(utf8Text, style, provider, out Unsafe.As<nuint, nuint_t>(ref result));
1233Unsafe.SkipInit(out result);
1234return 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);
405T[] @this = Unsafe.As<T[]>(this);
415T[] @this = Unsafe.As<T[]>(this);
423T[] @this = Unsafe.As<T[]>(this);
431T[] @this = Unsafe.As<T[]>(this);
444T[] @this = Unsafe.As<T[]>(this);
463T[] @this = Unsafe.As<T[]>(this);
484T[] @this = Unsafe.As<T[]>(this);
src\System\Runtime\CompilerServices\AsyncHelpers.CoreCLR.cs (15)
88return Unsafe.As<byte, object>(ref Unsafe.Add(ref data, (DataOffset - PointerSize) + index * PointerSize));
105return Unsafe.As<byte, ExecutionContext?>(ref Unsafe.Add(ref data, (DataOffset - PointerSize) + index * PointerSize));
115Unsafe.As<byte, Exception>(ref Unsafe.Add(ref data, (DataOffset - PointerSize) + index * PointerSize)) = ex;
124return ref Unsafe.NullRef<byte>();
126return ref Unsafe.Add(ref data, (DataOffset - PointerSize) + index * PointerSize);
314Unsafe.As<byte, object?>(ref Unsafe.Add(ref RuntimeHelpers.GetRawData(newContinuation), keepAliveOffset)) = loaderAllocator;
327Unsafe.As<byte, object?>(ref Unsafe.Add(ref RuntimeHelpers.GetRawData(newContinuation), keepAliveOffset)) = GCHandle.FromIntPtr(loaderAllocatorHandle).Target;
393return Unsafe.As<Action>(action);
401return Unsafe.As<Continuation>(stateObject);
763private 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));
393ref Unsafe.As<RawData>(obj).Data;
403rawSize += (uint)Unsafe.As<RawArrayData>(obj).Length * (nuint)pMT->ComponentSize;
424return ref Unsafe.As<byte, int>(ref Unsafe.As<RawArrayData>(array).Data);
631/// This API returns the same value as <see cref="Unsafe.SizeOf{T}"/> for the type that <paramref name="type"/> represents.
718private MethodDescChunk* GetMethodDescChunk() => (MethodDescChunk*)(((byte*)Unsafe.AsPointer<MethodDesc>(ref this)) - (sizeof(MethodDescChunk) + ChunkIndex * sizeof(IntPtr)));
1054return *(RuntimeType*)Unsafe.AsPointer(ref _exposedClassObject);
1084return ref Unsafe.AsRef<byte>((byte*)((nuint)p & ~(nuint)DynamicStaticsInfo.ISCLASSNOTINITED));
1162return *(RuntimeType*)Unsafe.AsPointer(ref ExposedClassObjectRaw);
1175return ref Unsafe.Subtract(ref Unsafe.As<MethodTableAuxiliaryData, DynamicStaticsInfo>(ref this), 1);
1183return ref Unsafe.Subtract(ref Unsafe.As<MethodTableAuxiliaryData, ThreadStaticsInfo>(ref this), 1);
src\System\StubHelpers.cs (25)
573if (Unsafe.IsNullRef(ref cleanupWorkList))
608Unsafe.WriteUnaligned(unmanaged, ConvertToNative(managed));
613managed = new DateTime(ConvertToManaged(Unsafe.ReadUnaligned<double>(unmanaged)));
1240Span<T> elements = new(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(managedArray)), managedArray.Length);
1250Span<T> elements = new(ref Unsafe.As<byte, T>(ref MemoryMarshal.GetArrayDataReference(managedArray)), managedArray.Length);
1361ConvertToManaged(ref managed, unmanaged, ref Unsafe.NullRef<CleanupWorkListElement?>());
1366ConvertToUnmanaged(ref managed, unmanaged, ref Unsafe.NullRef<CleanupWorkListElement?>());
1371Free(ref Unsafe.NullRef<T>(), unmanaged, ref Unsafe.NullRef<CleanupWorkListElement?>());
1412SpanHelpers.Memmove(ref *unmanaged, ref Unsafe.As<T, byte>(ref managed), (nuint)sizeof(T));
1436SpanHelpers.Memmove(ref Unsafe.As<T, byte>(ref managed), ref *unmanaged, (nuint)sizeof(T));
1585Methods.Free(ref Unsafe.NullRef<byte>(), unmanaged, ref cleanupWorkList);
1622ConvertToManaged(managed, unmanaged, ref Unsafe.NullRef<CleanupWorkListElement?>());
1627ConvertToUnmanaged(managed, unmanaged, ref Unsafe.NullRef<CleanupWorkListElement?>());
1632Free(default, unmanaged, ref Unsafe.NullRef<CleanupWorkListElement?>());
1645StructureMarshaler<T>.ConvertToUnmanaged(ref Unsafe.As<byte, T>(ref managed.GetRawData()), unmanaged, ref cleanupWorkList);
1649LayoutClassMarshaler<T>.ConvertToUnmanaged(Unsafe.As<object, T>(ref managed), unmanaged, ref cleanupWorkList);
1657StructureMarshaler<T>.ConvertToManaged(ref Unsafe.As<byte, T>(ref managed.GetRawData()), unmanaged, ref cleanupWorkList);
1661LayoutClassMarshaler<T>.ConvertToManaged(Unsafe.As<object, T>(ref managed), unmanaged, ref cleanupWorkList);
1669ref byte managedRef = ref Unsafe.NullRef<byte>();
1676StructureMarshaler<T>.Free(ref Unsafe.As<byte, T>(ref managedRef), unmanaged, ref cleanupWorkList);
1680LayoutClassMarshaler<T>.Free(Unsafe.As<object?, T?>(ref managed), unmanaged, ref cleanupWorkList);
1713Unsafe.WriteUnaligned(unmanaged, value);
1718TUnmanaged value = Unsafe.ReadUnaligned<TUnmanaged>(unmanaged);
2413LayoutTypeConvertToUnmanaged(*obj, pNative, 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);