Unsafe

src\libraries\Common\src\System\HexConverter.cs (6)

118ref ushort destRef = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars)); 139uint i32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref srcRef, pos)); 254ref ushort srcRef = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars)); 312Unsafe.WriteUnaligned(ref Unsafe.Add(ref destRef, offset / 2), output.AsUInt64().ToScalar());

src\libraries\Common\src\System\Number.NumberBuffer.cs (1)

33public readonly byte* DigitsPtr => (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(Digits)); // safe since constructor expects Digits to refer to unmovable memory

src\libraries\System.Private.CoreLib\src\System\Activator.RuntimeType.cs (2)

152return Unsafe.As<object, T>(ref o); 157rtType.CallDefaultStructConstructor(ref Unsafe.As<T, byte>(ref t));

src\libraries\System.Private.CoreLib\src\System\Array.cs (39)

src\libraries\System.Private.CoreLib\src\System\BitConverter.cs (51)

src\libraries\System.Private.CoreLib\src\System\Buffer.cs (14)

52Memmove(ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(dst), uDstOffset), ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(src), uSrcOffset), uCount); 84return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index); 95Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index) = value; 157ref Unsafe.As<T, byte>(ref destination), 158ref Unsafe.As<T, byte>(ref source), 165ref Unsafe.As<T, byte>(ref destination), 166ref Unsafe.As<T, byte>(ref source), 192if (Unsafe.AreSame(ref source, ref destination)) 196if ((nuint)(nint)Unsafe.ByteOffset(ref source, ref destination) >= byteCount) 203destination = ref Unsafe.AddByteOffset(ref destination, BulkMoveWithWriteBarrierChunk); 204source = ref Unsafe.AddByteOffset(ref source, BulkMoveWithWriteBarrierChunk); 214__BulkMoveWithWriteBarrier(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);

src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.ReverseEndianness.cs (6)

297if (Unsafe.AreSame(ref sourceRef, ref destRef) || 328Unsafe.Add(ref destRef, i) = TReverser.Reverse(Unsafe.Add(ref sourceRef, i)); 361Unsafe.Add(ref destRef, i) = TReverser.Reverse(Unsafe.Add(ref sourceRef, i)); 386if (Unsafe.AreSame(ref MemoryMarshal.GetReference(source), ref MemoryMarshal.GetReference(destination)) ||

src\libraries\System.Private.CoreLib\src\System\Buffers\SharedArrayPool.cs (3)

63buffer = Unsafe.As<T[]?>(tlsBuckets[bucketIndex].Array); 82buffer = Unsafe.As<T[]?>(b.TryPop()); 408Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(arrays), count) = array; // arrays[count] = array, but avoiding stelemref

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64DecoderHelper.cs (15)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64EncoderHelper.cs (13)

629Unsafe.WriteUnaligned(bufferBytes + destinationIndex, result); 648uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18)); 649uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F)); 650uint i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F)); 651uint i3 = Unsafe.Add(ref encodingMap, (IntPtr)(i & 0x3F)); 705uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 10)); 706uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 4) & 0x3F)); 709Unsafe.WriteUnaligned(dest, result); 720uint i0 = Unsafe.Add(ref encodingMap, (IntPtr)(i >> 18)); 721uint i1 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 12) & 0x3F)); 722uint i2 = Unsafe.Add(ref encodingMap, (IntPtr)((i >> 6) & 0x3F)); 725Unsafe.WriteUnaligned(dest, result); 769Unsafe.WriteUnaligned(destination, result);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Helper\Base64Helper.cs (4)

21int vectorElements = Unsafe.SizeOf<TVector>(); 35int vectorElements = Unsafe.SizeOf<TVector>(); 49int vectorElements = Unsafe.SizeOf<TVector>(); 63int vectorElements = Unsafe.SizeOf<TVector>();

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlDecoder.cs (7)

315if (decoder.IsValidPadding(Unsafe.Subtract(ref ptrToLastElement, 1))) 779int i0 = Unsafe.Add(ref decodingMap, (int)t0); 780int i1 = Unsafe.Add(ref decodingMap, (int)t1); 781int i2 = Unsafe.Add(ref decodingMap, (int)t2); 782int i3 = Unsafe.Add(ref decodingMap, (int)t3); 828int i0 = Unsafe.Add(ref decodingMap, (IntPtr)t0); 829int i1 = Unsafe.Add(ref decodingMap, (IntPtr)t1);

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Url\Base64UrlEncoder.cs (17)

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\FormattingHelpers.CountDigits.cs (3)

28nint elementOffset = Unsafe.Add(ref MemoryMarshal.GetReference(log2ToPow10), BitOperations.Log2(value)); 56ulong powerOf10 = Unsafe.Add(ref MemoryMarshal.GetReference(powersOf10), elementOffset); 106long tableValue = Unsafe.Add(ref MemoryMarshal.GetReference(table), uint.Log2(value));

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\ParserHelpers.cs (2)

65Unsafe.SkipInit(out value); // bypass language initialization rules since we're about to throw 66Unsafe.SkipInit(out bytesConsumed);

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\ByReference.cs (1)

17public static ByReference Create<T>(ref T p) => new ByReference(ref Unsafe.As<T, byte>(ref p));

src\libraries\System.Private.CoreLib\src\System\Byte.cs (1)

322result = Unsafe.Add(ref MemoryMarshal.GetReference(source), source.Length - sizeof(byte));

src\libraries\System.Private.CoreLib\src\System\Char.cs (3)

1206sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(char)); 1209result = Unsafe.ReadUnaligned<char>(ref sourceRef); 1257result = Unsafe.ReadUnaligned<char>(ref sourceRef);

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\ArraySortHelper.cs (21)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\Dictionary.cs (17)

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\HashSet.cs (7)

447return Unsafe.As<IAlternateEqualityComparer<TAlternate, T>>(set._comparer); 470ref int bucket = ref Unsafe.NullRef<int>(); 606public bool Contains(TAlternate item) => !Unsafe.IsNullRef(in FindValue(item)); 615if (!Unsafe.IsNullRef(in value)) 631ref Entry entry = ref Unsafe.NullRef<Entry>(); 675value = ref Unsafe.NullRef<T>(); 1426ref int bucket = ref Unsafe.NullRef<int>();

src\libraries\System.Private.CoreLib\src\System\Collections\Generic\RandomizedStringEqualityComparer.cs (2)

83ref Unsafe.As<char, byte>(ref obj.GetRawStringData()), 90ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(alternate)),

src\libraries\System.Private.CoreLib\src\System\ComAwareWeakReference.cs (4)

146return Unsafe.As<ComAwareWeakReference>(GCHandle.InternalGet(taggedHandle & ~HandleTagBits)); 153return Unsafe.As<ComAwareWeakReference>(GCHandle.InternalGet(taggedHandle & ~HandleTagBits)).Target; 159return Unsafe.As<ComAwareWeakReference>(GCHandle.InternalGet(taggedHandle & ~HandleTagBits))._weakHandle; 167Unsafe.As<ComAwareWeakReference>(GCHandle.InternalGet(taggedHandle & ~HandleTagBits));

src\libraries\System.Private.CoreLib\src\System\Convert.Base64.cs (24)

src\libraries\System.Private.CoreLib\src\System\Convert.cs (21)

2488ref ushort dest = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars)); 2489ref byte src = ref Unsafe.As<ushort, byte>(ref dest); 2495dest = ref Unsafe.Add(ref dest, charLengthRequired); 2496src = ref Unsafe.Add(ref src, charLengthRequired); 2501ref byte srcBeginningPlus31 = ref Unsafe.Add(ref srcBeginning, 31); 2502while (Unsafe.IsAddressGreaterThan(ref src, ref srcBeginningPlus31)) 2504src = ref Unsafe.Subtract(ref src, 32); 2505dest = ref Unsafe.Subtract(ref dest, 32); 2517ref byte srcBeginningPlus15 = ref Unsafe.Add(ref srcBeginning, 15); 2518while (Unsafe.IsAddressGreaterThan(ref src, ref srcBeginningPlus15)) 2520src = ref Unsafe.Subtract(ref src, 16); 2521dest = ref Unsafe.Subtract(ref dest, 16); 2531ref byte srcBeginningPlus3 = ref Unsafe.Add(ref srcBeginning, 3); 2532while (Unsafe.IsAddressGreaterThan(ref src, ref srcBeginningPlus3)) 2534dest = ref Unsafe.Subtract(ref dest, 4); 2535src = ref Unsafe.Subtract(ref src, 4); 2536Ascii.WidenFourAsciiBytesToUtf16AndWriteToBuffer(ref Unsafe.As<ushort, char>(ref dest), Unsafe.ReadUnaligned<uint>(ref src)); 2543Debug.Assert(Unsafe.AreSame(ref srcBeginning, ref src)); 2544Debug.Assert(Unsafe.AreSame(ref srcBeginning, ref Unsafe.As<ushort, byte>(ref dest)),

src\libraries\System.Private.CoreLib\src\System\Decimal.cs (6)

1188Unsafe.WriteUnaligned(ref address, hi32); 1189Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref address, sizeof(uint)), lo64); 1217Unsafe.WriteUnaligned(ref address, lo64); 1218Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref address, sizeof(ulong)), hi32);

src\libraries\System.Private.CoreLib\src\System\Decimal.DecCalc.cs (11)

src\libraries\System.Private.CoreLib\src\System\Delegate.cs (3)

81public bool HasSingleTarget => Unsafe.As<MulticastDelegate>(this).HasSingleTarget; 97=> new InvocationListEnumerator<TDelegate>(Unsafe.As<MulticastDelegate>(d)); 131if ((_current = Unsafe.As<TDelegate>(_delegate?.TryGetAt(index))) == null)

src\libraries\System.Private.CoreLib\src\System\Enum.cs (111)

src\libraries\System.Private.CoreLib\src\System\Globalization\CharUnicodeInfo.cs (27)

src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.cs (2)

367Debug.Assert(!Unsafe.IsNullRef(ref MemoryMarshal.GetReference(span1))); 368Debug.Assert(!Unsafe.IsNullRef(ref MemoryMarshal.GetReference(span2)));

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)

src\libraries\System.Private.CoreLib\src\System\Globalization\InvariantModeCasing.cs (5)

172char charB = Unsafe.Add(ref source, 1); 201charA = ref Unsafe.Add(ref charA, codePointLengthA); 202charB = ref Unsafe.Add(ref charB, codePointLengthB); 213charA = ref Unsafe.Add(ref charA, codePointLengthA); 214charB = ref Unsafe.Add(ref charB, codePointLengthB);

src\libraries\System.Private.CoreLib\src\System\Globalization\NumberFormatInfo.cs (28)

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)

src\libraries\System.Private.CoreLib\src\System\Globalization\OrdinalCasing.Icu.cs (11)

src\libraries\System.Private.CoreLib\src\System\Globalization\TextInfo.cs (1)

290uint tempValue = Unsafe.ReadUnaligned<uint>(pSource + currIdx);

src\libraries\System.Private.CoreLib\src\System\Guid.cs (24)

246return Unsafe.As<GuidResult, Guid>(ref Unsafe.AsRef(in this)); 322Unsafe.AsRef(in result._a) = (int)(unix_ts_ms >> 16); 323Unsafe.AsRef(in result._b) = (short)(unix_ts_ms); 325Unsafe.AsRef(in result._c) = (short)((result._c & ~VersionMask) | Version7Value); 326Unsafe.AsRef(in result._d) = (byte)((result._d & ~Variant10xxMask) | Variant10xxValue); 770Unsafe.Add(ref result._d, i) = (byte)byteVal; 977ref int r = ref Unsafe.AsRef(in _a); 978return r ^ Unsafe.Add(ref r, 1) ^ Unsafe.Add(ref r, 2) ^ Unsafe.Add(ref r, 3); 992return Vector128.LoadUnsafe(ref Unsafe.As<Guid, byte>(ref Unsafe.AsRef(in left))) == Vector128.LoadUnsafe(ref Unsafe.As<Guid, byte>(ref Unsafe.AsRef(in right))); 995ref int rA = ref Unsafe.AsRef(in left._a); 996ref int rB = ref Unsafe.AsRef(in right._a); 1001&& Unsafe.Add(ref rA, 1) == Unsafe.Add(ref rB, 1) 1002&& Unsafe.Add(ref rA, 2) == Unsafe.Add(ref rB, 2) 1003&& Unsafe.Add(ref rA, 3) == Unsafe.Add(ref rB, 3); 1428Vector128<byte> srcVec = Unsafe.As<Guid, Vector128<byte>>(ref value);

src\libraries\System.Private.CoreLib\src\System\Guid.Unix.cs (2)

29Unsafe.AsRef(in g._c) = (short)((g._c & ~VersionMask) | Version4Value); 31Unsafe.AsRef(in g._d) = (byte)((g._d & ~Variant10xxMask) | Variant10xxValue);

src\libraries\System.Private.CoreLib\src\System\HashCode.cs (27)

src\libraries\System.Private.CoreLib\src\System\Int128.cs (5)

804sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - Size); 807result = Unsafe.ReadUnaligned<Int128>(ref sourceRef); 823result |= Unsafe.Add(ref sourceRef, i); 887result = Unsafe.ReadUnaligned<Int128>(ref sourceRef); 905result |= Unsafe.Add(ref sourceRef, i);

src\libraries\System.Private.CoreLib\src\System\Int16.cs (3)

348sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(short)); 351result = Unsafe.ReadUnaligned<short>(ref sourceRef); 424result = Unsafe.ReadUnaligned<short>(ref sourceRef);

src\libraries\System.Private.CoreLib\src\System\Int32.cs (5)

368sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(int)); 371result = Unsafe.ReadUnaligned<int>(ref sourceRef); 387result |= Unsafe.Add(ref sourceRef, i); 451result = Unsafe.ReadUnaligned<int>(ref sourceRef); 469result |= Unsafe.Add(ref sourceRef, i);

src\libraries\System.Private.CoreLib\src\System\Int64.cs (5)

365sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(long)); 368result = Unsafe.ReadUnaligned<long>(ref sourceRef); 384result |= Unsafe.Add(ref sourceRef, i); 448result = Unsafe.ReadUnaligned<long>(ref sourceRef); 466result |= Unsafe.Add(ref sourceRef, i);

src\libraries\System.Private.CoreLib\src\System\IntPtr.cs (23)

src\libraries\System.Private.CoreLib\src\System\IO\BinaryReader.cs (2)

360MemoryStream mStream = Unsafe.As<MemoryStream>(_stream); 480return Unsafe.As<MemoryStream>(_stream).InternalReadSpan(buffer.Length);

src\libraries\System.Private.CoreLib\src\System\IO\UnmanagedMemoryAccessor.cs (14)

152result = Unsafe.ReadUnaligned<short>(pointer + _offset + position); 177result = Unsafe.ReadUnaligned<int>(pointer + _offset + position); 202result = Unsafe.ReadUnaligned<long>(pointer + _offset + position); 232lo = Unsafe.ReadUnaligned<int>(pointer); 233mid = Unsafe.ReadUnaligned<int>(pointer + 4); 234hi = Unsafe.ReadUnaligned<int>(pointer + 8); 235flags = Unsafe.ReadUnaligned<int>(pointer + 12); 401Unsafe.WriteUnaligned(pointer + _offset + position, value); 424Unsafe.WriteUnaligned(pointer + _offset + position, value); 447Unsafe.WriteUnaligned(pointer + _offset + position, value); 475Unsafe.WriteUnaligned(pointer, bits[0]); 476Unsafe.WriteUnaligned(pointer + 4, bits[1]); 477Unsafe.WriteUnaligned(pointer + 8, bits[2]); 478Unsafe.WriteUnaligned(pointer + 12, bits[3]);

src\libraries\System.Private.CoreLib\src\System\Marvin.cs (11)

64p0 += Unsafe.ReadUnaligned<uint>(ref data); 65uint nextUInt32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.AddByteOffset(ref data, 4)); 80data = ref Unsafe.AddByteOffset(ref data, 8); 101p0 += Unsafe.ReadUnaligned<uint>(ref data); 116uint partialResult = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref Unsafe.AddByteOffset(ref data, (nuint)count & 7), -4)); 182partialResult = Unsafe.AddByteOffset(ref data, (nuint)count & 2); 208partialResult |= (uint)Unsafe.ReadUnaligned<ushort>(ref data); 212partialResult |= (uint)Unsafe.ReadUnaligned<ushort>(ref data);

src\libraries\System.Private.CoreLib\src\System\Marvin.OrdinalIgnoreCase.cs (6)

28tempValue = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref data, byteOffset))); 45tempValue = Unsafe.AddByteOffset(ref data, byteOffset); 78return ComputeHash32OrdinalIgnoreCaseSlow(ref Unsafe.AddByteOffset(ref data, byteOffset), (int)ucount, p0, p1); 93int hash = ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(scratch)), (uint)charsWritten * 2, p0, p1);

src\libraries\System.Private.CoreLib\src\System\Memory.cs (17)

275ref T refToReturn = ref Unsafe.NullRef<T>(); 287refToReturn = ref Unsafe.As<char, T>(ref Unsafe.As<string>(tmpObject).GetRawStringData()); 288lengthOfUnderlyingSpan = Unsafe.As<string>(tmpObject).Length; 304refToReturn = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject)); 305lengthOfUnderlyingSpan = Unsafe.As<T[]>(tmpObject).Length; 316Span<T> memoryManagerSpan = Unsafe.As<MemoryManager<T>>(tmpObject).GetSpan(); 345refToReturn = ref Unsafe.Add(ref refToReturn, desiredStartIndex); 402ref char stringData = ref Unsafe.Add(ref s.GetRawStringData(), _index); 403return new MemoryHandle(Unsafe.AsPointer(ref stringData), handle); 414void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index & ReadOnlyMemory<T>.RemoveFlagsBitMask); 421void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index); 428return Unsafe.As<MemoryManager<T>>(tmpObject).Pin(_index);

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (448)

src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Globalization.cs (1)

325ref Unsafe.Add(ref MemoryMarshal.GetReference(span), span.Length - value.Length),

src\libraries\System.Private.CoreLib\src\System\Number.BigInteger.cs (1)

1329(byte*)Unsafe.AsPointer(ref _blocks[0]), // This is safe to do since we are a ref struct

src\libraries\System.Private.CoreLib\src\System\Number.Formatting.cs (8)

617if (source.TryCopyTo(Unsafe.BitCast<Span<TChar>, Span<char>>(destination))) 628return Encoding.UTF8.TryGetBytes(source, Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out charsWritten); 1573Unsafe.CopyBlockUnaligned( 1575ref Unsafe.Add(ref MemoryMarshal.GetReference(typeof(TChar) == typeof(char) ? TwoDigitsCharsAsBytes : TwoDigitsBytes), (uint)sizeof(TChar) * 2 * value), 1593Unsafe.CopyBlockUnaligned( 1595ref Unsafe.Add(ref charsArray, (uint)sizeof(TChar) * 2 * value), 1598Unsafe.CopyBlockUnaligned( 1600ref Unsafe.Add(ref charsArray, (uint)sizeof(TChar) * 2 * remainder),

src\libraries\System.Private.CoreLib\src\System\Number.NumberToFloatingPointBits.cs (1)

954ulong val = Unsafe.ReadUnaligned<ulong>(chars);

src\libraries\System.Private.CoreLib\src\System\Number.Parsing.cs (13)

src\libraries\System.Private.CoreLib\src\System\Numerics\BitOperations.cs (9)

393return Unsafe.AddByteOffset( 576return Unsafe.AddByteOffset( 876crc = Unsafe.Add(ref lookupTable, (nint)(byte)(crc ^ data)) ^ (crc >> 8); 885crc = Unsafe.Add(ref lookupTable, (nint)(byte)(crc ^ (byte)data)) ^ (crc >> 8); 887crc = Unsafe.Add(ref lookupTable, (nint)(byte)(crc ^ data)) ^ (crc >> 8); 901crc = Unsafe.Add(ref lookupTable, (nint)(byte)(crc ^ (byte)data)) ^ (crc >> 8); 903crc = Unsafe.Add(ref lookupTable, (nint)(byte)(crc ^ (byte)data)) ^ (crc >> 8); 905crc = Unsafe.Add(ref lookupTable, (nint)(byte)(crc ^ (byte)data)) ^ (crc >> 8); 907crc = Unsafe.Add(ref lookupTable, (nint)(byte)(crc ^ data)) ^ (crc >> 8);

src\libraries\System.Private.CoreLib\src\System\Numerics\Matrix3x2.cs (2)

55Unsafe.SkipInit(out this); 265Unsafe.SkipInit(out result);

src\libraries\System.Private.CoreLib\src\System\Numerics\Matrix3x2.Impl.cs (7)

23internal ref Impl AsImpl() => ref Unsafe.As<Matrix3x2, Impl>(ref this); 27internal readonly ref readonly Impl AsROImpl() => ref Unsafe.As<Matrix3x2, Impl>(ref Unsafe.AsRef(in this)); 33public ref Matrix3x2 AsM3x2() => ref Unsafe.As<Impl, Matrix3x2>(ref this); 75return Unsafe.Add(ref Unsafe.AsRef(in X), row)[column]; 85Unsafe.Add(ref X, row)[column] = value;

src\libraries\System.Private.CoreLib\src\System\Numerics\Matrix4x4.cs (3)

96Unsafe.SkipInit(out this); 111Unsafe.SkipInit(out this); 629Unsafe.SkipInit(out result);

src\libraries\System.Private.CoreLib\src\System\Numerics\Matrix4x4.Impl.cs (8)

26internal ref Impl AsImpl() => ref Unsafe.As<Matrix4x4, Impl>(ref this); 30internal readonly ref readonly Impl AsROImpl() => ref Unsafe.As<Matrix4x4, Impl>(ref Unsafe.AsRef(in this)); 36public ref Matrix4x4 AsM4x4() => ref Unsafe.As<Impl, Matrix4x4>(ref this); 93return Unsafe.Add(ref Unsafe.AsRef(in X), row)[column]; 103Unsafe.Add(ref X, row)[column] = value; 1232scale = Unsafe.ReadUnaligned<Vector3>(scales);

src\libraries\System.Private.CoreLib\src\System\Numerics\Plane.Extensions.cs (1)

19return Unsafe.BitCast<Plane, Vector4>(value);

src\libraries\System.Private.CoreLib\src\System\Numerics\Quaternion.Extensions.cs (1)

19return Unsafe.BitCast<Quaternion, Vector4>(value);

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector.cs (95)

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector_1.cs (30)

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); 980Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this); 1008Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this); 1022Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this); 1036Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector2.Extensions.cs (5)

74ref byte address = ref Unsafe.As<float, byte>(ref destination); 75Unsafe.WriteUnaligned(ref address, source); 86destination = ref Unsafe.Add(ref destination, (nint)elementOffset); 87Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref destination), source);

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector3.cs (17)

446return Unsafe.ReadUnaligned<Vector3>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 737ref readonly byte address = ref Unsafe.As<float, byte>(ref Unsafe.AsRef(in source)); 738return Unsafe.ReadUnaligned<Vector3>(in address); 747ref readonly byte address = ref Unsafe.As<float, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset)); 748return Unsafe.ReadUnaligned<Vector3>(in address); 990Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this); 1018Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this); 1032Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this); 1046Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector3.Extensions.cs (5)

src\libraries\System.Private.CoreLib\src\System\Numerics\Vector4.Extensions.cs (2)

20return Unsafe.BitCast<Vector4, Plane>(value); 32return Unsafe.BitCast<Vector4, Quaternion>(value);

src\libraries\System.Private.CoreLib\src\System\Numerics\VectorDebugView_1.cs (23)

src\libraries\System.Private.CoreLib\src\System\ReadOnlyMemory.cs (17)

197ref T refToReturn = ref Unsafe.NullRef<T>(); 209refToReturn = ref Unsafe.As<char, T>(ref Unsafe.As<string>(tmpObject).GetRawStringData()); 210lengthOfUnderlyingSpan = Unsafe.As<string>(tmpObject).Length; 226refToReturn = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject)); 227lengthOfUnderlyingSpan = Unsafe.As<T[]>(tmpObject).Length; 238Span<T> memoryManagerSpan = Unsafe.As<MemoryManager<T>>(tmpObject).GetSpan(); 267refToReturn = ref Unsafe.Add(ref refToReturn, desiredStartIndex); 317ref char stringData = ref Unsafe.Add(ref s.GetRawStringData(), _index); 318return new MemoryHandle(Unsafe.AsPointer(ref stringData), handle); 329void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index & RemoveFlagsBitMask); 336void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index); 343return Unsafe.As<MemoryManager<T>>(tmpObject).Pin(_index);

src\libraries\System.Private.CoreLib\src\System\ReadOnlySpan.cs (9)

81_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */); 117_reference = ref Unsafe.AsRef(in reference); 148return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */); 225return new ReadOnlySpan<T>(ref Unsafe.As<TDerived, T>(ref items._reference), items.Length); 278ref T ret = ref Unsafe.NullRef<T>(); 334Unsafe.AreSame(ref left._reference, ref right._reference); 344return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length)); 362return new ReadOnlySpan<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start); 385return new ReadOnlySpan<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), length);

src\libraries\System.Private.CoreLib\src\System\Reflection\ConstructorInvoker.cs (4)

320copyOfArgs = new(ref Unsafe.AsRef<object?>(pArgStorage), _argCount); 351copyOfArgs = new(ref Unsafe.AsRef<object?>(pStorage), _argCount); 370ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i).GetRawData()) : 371ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i));

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)

src\libraries\System.Private.CoreLib\src\System\Reflection\MethodBaseInvoker.Constructor.cs (3)

29Span<object?> copyOfArgs = new(ref Unsafe.AsRef<object?>(pStorage), argCount); 44ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i).GetRawData()) : 45ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i));

src\libraries\System.Private.CoreLib\src\System\Reflection\MethodBaseInvoker.cs (4)

205copyOfArgs = new(ref Unsafe.AsRef<object?>(pArgStorage), _argCount); 240copyOfArgs = new(ref Unsafe.AsRef<object?>(pStorage), _argCount); 256ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i).GetRawData()) : 257ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i));

src\libraries\System.Private.CoreLib\src\System\Reflection\MethodInvoker.cs (4)

373copyOfArgs = new(ref Unsafe.AsRef<object?>(pArgStorage), _argCount); 404copyOfArgs = new(ref Unsafe.AsRef<object?>(pStorage), _argCount); 423ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i).GetRawData()) : 424ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i));

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\AsyncTaskMethodBuilderT.cs (4)

108ref TaskAwaiter ta = ref Unsafe.As<TAwaiter, TaskAwaiter>(ref awaiter); // relies on TaskAwaiter/TaskAwaiter<T> having the same layout 113ref ConfiguredTaskAwaitable.ConfiguredTaskAwaiter ta = ref Unsafe.As<TAwaiter, ConfiguredTaskAwaitable.ConfiguredTaskAwaiter>(ref awaiter); 292Unsafe.As<AsyncStateMachineBox<TStateMachine>>(s).StateMachine!.MoveNext(); 343return ref Unsafe.As<object?, ExecutionContext?>(ref m_stateObject);

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\CastCache.cs (7)

109return ref Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref table.GetRawData(), (nint)sizeof(nint))); 123return ref Unsafe.Add(ref tableData, 1); 129return ref Unsafe.As<int, uint>(ref Unsafe.Add(ref tableData, 2)); 136return ref Unsafe.Add(ref Unsafe.As<int, CastCacheEntry>(ref tableData), index + 1);

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\GenericCache.cs (5)

112return ref Unsafe.As<byte, Entry>(ref Unsafe.As<RawArrayData>(table).Data); 138return ref Unsafe.Add(ref Unsafe.As<byte, Entry>(ref Unsafe.As<RawArrayData>(table).Data), index + 1);

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\PoolingAsyncValueTaskMethodBuilderT.cs (2)

370return ref Unsafe.As<object?, StateMachineBox<TStateMachine>?>(ref s_perCoreCache[i].Object); 392Unsafe.As<StateMachineBox<TStateMachine>>(s).StateMachine!.MoveNext();

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\QCallHandles.cs (9)

17_ptr = Unsafe.AsPointer(ref s); 33return new ObjectHandleOnStack(Unsafe.AsPointer(ref o)); 66return new ByteRefOnStack(Unsafe.AsPointer(ref byteRef)); 77_ptr = Unsafe.AsPointer(ref stackMark); 89_ptr = Unsafe.AsPointer(ref module); 95_ptr = Unsafe.AsPointer(ref module); 108_ptr = Unsafe.AsPointer(ref assembly); 121_ptr = Unsafe.AsPointer(ref type); 127_ptr = Unsafe.AsPointer(ref rth);

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\RuntimeHelpers.cs (3)

54dest = Unsafe.As<T[]>(Array.CreateInstanceFromArrayType(array.GetType(), length)); 64ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), offset), 154=> new ReadOnlySpan<T>(ref Unsafe.As<byte, T>(ref GetSpanDataFrom(fldHandle, typeof(T).TypeHandle, out int length)), length);

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\Unsafe.cs (1)

751return AsPointer(ref Unsafe.AsRef(in source)) == null;

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\ValueTaskAwaiter.cs (6)

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\GCHandle.cs (5)

135return (IntPtr)Unsafe.AsPointer(ref Unsafe.As<string>(target).GetRawStringData()); 139return (IntPtr)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<Array>(target))); 142return (IntPtr)Unsafe.AsPointer(ref target.GetRawData());

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshal.cs (8)

169void* pRawData = Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(arr)); 178void* pRawData = Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(arr)); 315return Unsafe.ReadUnaligned<short>(addr); 339return Unsafe.ReadUnaligned<int>(addr); 386return Unsafe.ReadUnaligned<long>(addr); 426Unsafe.WriteUnaligned(addr, val); 459Unsafe.WriteUnaligned(addr, val); 510Unsafe.WriteUnaligned(addr, val);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\AnsiStringMarshaller.cs (1)

91_unmanagedValue = (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(buffer));

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ArrayMarshaller.cs (2)

179return (TUnmanagedElement*)Unsafe.AsPointer(ref GetPinnableReference()); 199return ref Unsafe.NullRef<T>();

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\BStrStringMarshaller.cs (1)

90byte* pBuffer = (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(buffer));

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ComVariant.cs (1)

581return ref Unsafe.As<UnionTypes, T>(ref _typeUnion._unionTypes);

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\PointerArrayMarshaller.cs (5)

53=> Unsafe.As<IntPtr[]>(managed); 84=> Unsafe.As<IntPtr[]>(managed); 159public ReadOnlySpan<IntPtr> GetManagedValuesSource() => Unsafe.As<IntPtr[]>(_managedArray); 180return (TUnmanagedElement*)Unsafe.AsPointer(ref GetPinnableReference()); 200return ref Unsafe.NullRef<byte>();

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\ReadOnlySpanMarshaller.cs (3)

44if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 104if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 149return (TUnmanagedElement*)Unsafe.AsPointer(ref GetPinnableReference());

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\SpanMarshaller.cs (3)

38if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 132if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 176return (TUnmanagedElement*)Unsafe.AsPointer(ref GetPinnableReference());

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\Marshalling\Utf8StringMarshaller.cs (1)

95_unmanagedValue = (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(buffer));

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\MemoryMarshal.cs (19)

37ref Unsafe.As<T, byte>(ref GetReference(span)), 60ref Unsafe.As<T, byte>(ref GetReference(span)), 93internal static unsafe ref T GetNonNullPinnableReference<T>(Span<T> span) => ref (span.Length != 0) ? ref Unsafe.AsRef(in span._reference) : ref Unsafe.AsRef<T>((void*)1); 100internal static unsafe ref T GetNonNullPinnableReference<T>(ReadOnlySpan<T> span) => ref (span.Length != 0) ? ref Unsafe.AsRef(in span._reference) : ref Unsafe.AsRef<T>((void*)1); 153ref Unsafe.As<TFrom, TTo>(ref span._reference), 208ref Unsafe.As<TFrom, TTo>(ref GetReference(span)), 227new Span<T>(ref Unsafe.AsRef(in reference), length); 244new ReadOnlySpan<T>(ref Unsafe.AsRef(in reference), length); 290segment = new ArraySegment<T>(Unsafe.As<T[]>(obj), index & ReadOnlyMemory<T>.RemoveFlagsBitMask, length); 299if (Unsafe.As<MemoryManager<T>>(obj).TryGetArray(out ArraySegment<T> tempArraySegment)) 411T[] array = Unsafe.As<T[]>(obj); 479return Unsafe.ReadUnaligned<T>(ref GetReference(source)); 499value = Unsafe.ReadUnaligned<T>(ref GetReference(source)); 518Unsafe.WriteUnaligned(ref GetReference(destination), value); 537Unsafe.WriteUnaligned(ref GetReference(destination), value); 560return ref Unsafe.As<byte, T>(ref GetReference(span)); 582return 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\InteropServices\SafeBuffer.cs (6)

195return Unsafe.ReadUnaligned<T>(ptr); 249Unsafe.Add(ref structure, (nint)(uint)i) = Unsafe.ReadUnaligned<T>(ptr + alignedSizeofT * (uint)i); 282Unsafe.WriteUnaligned(ptr, value); 338Unsafe.WriteUnaligned(ptr + alignedSizeofT * (uint)i, Unsafe.Add(ref structure, (nint)(uint)i));

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\ISimdVector_2.cs (1)

275Unsafe.SkipInit(out TSelf result);

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.cs (54)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128.Numerics.cs (20)

61return Unsafe.BitCast<Vector128<float>, Plane>(value); 74return Unsafe.BitCast<Vector128<float>, Quaternion>(value); 87return Unsafe.BitCast<Plane, Vector128<float>>(value); 100return Unsafe.BitCast<Quaternion, Vector128<float>>(value); 125return Unsafe.BitCast<Vector4, Vector128<float>>(value); 141ref byte address = ref Unsafe.As<Vector<T>, byte>(ref value); 142return Unsafe.ReadUnaligned<Vector128<T>>(ref address); 154Unsafe.SkipInit(out Vector128<float> result); 155Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<float>, byte>(ref result), value); 168Unsafe.SkipInit(out Vector128<float> result); 169Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<float>, byte>(ref result), value); 180ref byte address = ref Unsafe.As<Vector128<float>, byte>(ref value); 181return Unsafe.ReadUnaligned<Vector2>(ref address); 191ref byte address = ref Unsafe.As<Vector128<float>, byte>(ref value); 192return Unsafe.ReadUnaligned<Vector3>(ref address); 204return Unsafe.BitCast<Vector128<float>, Vector4>(value); 221Unsafe.WriteUnaligned(ref Unsafe.As<Vector<T>, byte>(ref result), value);

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128_1.cs (1)

66Unsafe.SkipInit(out Vector128<T> result);

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector128DebugView_1.cs (23)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256.cs (54)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256_1.cs (1)

65Unsafe.SkipInit(out Vector256<T> result);

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector256DebugView_1.cs (23)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512.cs (53)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512_1.cs (1)

65Unsafe.SkipInit(out Vector512<T> result);

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector512DebugView_1.cs (23)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64.cs (123)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64_1.cs (18)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\Vector64DebugView_1.cs (23)

src\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\VectorMath.cs (113)

src\libraries\System.Private.CoreLib\src\System\SByte.cs (1)

348result = (sbyte)Unsafe.Add(ref MemoryMarshal.GetReference(source), source.Length - sizeof(sbyte));

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\Any2CharPackedIgnoreCaseSearchValues.cs (2)

57ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 65ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);

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)

49ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 57ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 65ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 73ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 81ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 89ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state);

src\libraries\System.Private.CoreLib\src\System\SearchValues\BitmapCharSearchValues.cs (5)

73ref char searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength); 77while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd)) 82return (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref cur) / sizeof(char)); 85cur = ref Unsafe.Add(ref cur, 1); 98char c = Unsafe.Add(ref searchSpace, searchSpaceLength);

src\libraries\System.Private.CoreLib\src\System\SearchValues\IndexOfAnyAsciiSearcher.cs (102)

src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticMap.cs (69)

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\RangeCharSearchValues.cs (6)

45ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(span)), 46Unsafe.As<char, ushort>(ref _lowInclusive), 47Unsafe.As<char, ushort>(ref _highInclusive), 55ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(span)), 56Unsafe.As<char, ushort>(ref _lowInclusive), 57Unsafe.As<char, ushort>(ref _highInclusive),

src\libraries\System.Private.CoreLib\src\System\SearchValues\SearchValues.T.cs (1)

59"\"" + new string(Unsafe.As<T[], char[]>(ref values)) + "\"" :

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\AsciiStringSearchValuesTeddyBase.cs (48)

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\AhoCorasickNode.cs (2)

44int[] table = Unsafe.As<int[]>(children); 56return Unsafe.As<Dictionary<char, int>>(children).TryGetValue(c, out index);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\RabinKarp.cs (7)

120ref char end = ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (uint)(span.Length - hashLength)); 125hash = (hash << HashShiftPerElement) + TCaseSensitivity.TransformInput(Unsafe.Add(ref current, i)); 135if (Unsafe.Add(ref bucketsRef, hash % BucketCount) is string[] bucket) 137int startOffset = (int)((nuint)Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref current) / sizeof(char)); 145if (!Unsafe.IsAddressLessThan(ref current, ref end)) 151char next = TCaseSensitivity.TransformInput(Unsafe.Add(ref current, (uint)hashLength)); 155current = ref Unsafe.Add(ref current, 1);

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\Helpers\StringSearchValuesHelper.cs (28)

src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesThreeChars.cs (32)

src\libraries\System.Private.CoreLib\src\System\Span.cs (9)

86_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */); 153return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */); 271ref T ret = ref Unsafe.NullRef<T>(); 284SpanHelpers.ClearWithReferences(ref Unsafe.As<T, IntPtr>(ref _reference), (uint)_length * (nuint)(sizeof(T) / sizeof(nuint))); 288SpanHelpers.ClearWithoutReferences(ref Unsafe.As<T, byte>(ref _reference), (uint)_length * (nuint)sizeof(T)); 352Unsafe.AreSame(ref left._reference, ref right._reference); 368return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length)); 386return new Span<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start); 414return new Span<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), length);

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.BinarySearch.cs (1)

40int c = comparable.CompareTo(Unsafe.Add(ref spanStart, i));

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Byte.cs (75)

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.ByteMemOps.cs (98)

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Char.cs (75)

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.cs (37)

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.Packed.cs (111)

src\libraries\System.Private.CoreLib\src\System\SpanHelpers.T.cs (415)

src\libraries\System.Private.CoreLib\src\System\String.Comparison.cs (20)

30ref Unsafe.As<char, byte>(ref strA.GetRawStringData()), 31ref Unsafe.As<char, byte>(ref strB.GetRawStringData()), 45ref Unsafe.Add(ref strA.GetRawStringData(), (nint)(uint)indexA /* force zero-extension */), countA, 46ref Unsafe.Add(ref strB.GetRawStringData(), (nint)(uint)indexB /* force zero-extension */), countB); 421return Ordinal.CompareStringIgnoreCase(ref Unsafe.Add(ref strA.GetRawStringData(), indexA), lengthA, ref Unsafe.Add(ref strB.GetRawStringData(), indexB), lengthB); 570Ordinal.EqualsIgnoreCase(ref Unsafe.Add(ref GetRawStringData(), Length - value.Length), 605return Unsafe.Add(ref _firstChar, (nint)localLength - 1) == value; 758return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref _firstChar), (uint)_stringLength * 2 /* in bytes, not chars */, (uint)seed, (uint)(seed >> 32)); 779return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(value)), (uint)value.Length * 2 /* in bytes, not chars */, (uint)seed, (uint)(seed >> 32)); 877hash1 = BitOperations.RotateLeft(hash1, 5) + hash1 ^ Unsafe.ReadUnaligned<uint>(ptr); 878hash2 = BitOperations.RotateLeft(hash2, 5) + hash2 ^ Unsafe.ReadUnaligned<uint>(ptr + 1); 885hash1 = BitOperations.RotateLeft(hash1, 5) + hash1 ^ Unsafe.ReadUnaligned<uint>(ptr); 896hash2 = BitOperations.RotateLeft(hash2, 5) + hash2 ^ Unsafe.ReadUnaligned<uint>(ptr); 987p0 = Unsafe.ReadUnaligned<uint>(ptr); 988p1 = Unsafe.ReadUnaligned<uint>(ptr + 1); 1003p0 = Unsafe.ReadUnaligned<uint>(ptr); 1020p0 = Unsafe.ReadUnaligned<uint>(ptr); 1141ref Unsafe.As<char, byte>(ref this.GetRawStringData()), 1142ref Unsafe.As<char, byte>(ref value.GetRawStringData()),

src\libraries\System.Private.CoreLib\src\System\String.cs (8)

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 ushort GetRawStringDataAsUInt16() => ref Unsafe.As<char, ushort>(ref _firstChar); 572Unsafe.Add(ref result._firstChar, 1) = c2; 734return Unsafe.Add(ref _firstChar, (nint)(uint)index /* force zero-extension */);

src\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (25)

src\libraries\System.Private.CoreLib\src\System\String.Searching.cs (7)

37=> SpanHelpers.ContainsValueType(ref Unsafe.As<char, short>(ref _firstChar), (short)value, Length); 98int result = SpanHelpers.IndexOfChar(ref Unsafe.Add(ref _firstChar, startIndex), value, count); 138int result = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, startIndex), count).IndexOfAny(anyOf); 270=> SpanHelpers.LastIndexOfValueType(ref Unsafe.As<char, short>(ref _firstChar), (short)value, Length); 295int result = SpanHelpers.LastIndexOfValueType(ref Unsafe.As<char, short>(ref Unsafe.Add(ref _firstChar, startSearchAt)), (short)value, count); 343int result = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, startSearchAt), count).LastIndexOfAny(anyOf);

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.CaseConversion.cs (7)

318ulong nextBlockAsUInt64 = Unsafe.ReadUnaligned<ulong>(&pSrc[i]); 342Unsafe.WriteUnaligned(&pDest[i], nextBlockAsUInt64); 357Unsafe.WriteUnaligned(&pDest[i], narrowedBlock.ToScalar()); 377uint nextBlockAsUInt32 = Unsafe.ReadUnaligned<uint>(&pSrc[i]); 401Unsafe.WriteUnaligned(&pDest[i], nextBlockAsUInt32); 411Unsafe.WriteUnaligned(&pDest[i], widenedBlock.ToScalar()); 417Unsafe.WriteUnaligned(&pDest[i], narrowedBlock.ToScalar());

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.cs (36)

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Equality.cs (43)

src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Utility.cs (45)

src\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (12)

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Utility.cs (25)

src\libraries\System.Private.CoreLib\src\System\Text\Latin1Utility.Helpers.cs (9)

60Unsafe.WriteUnaligned(ref outputBuffer, Sse2.ConvertToUInt32(vecNarrow)); 68Unsafe.Add(ref outputBuffer, 1) = (byte)value; 70Unsafe.Add(ref outputBuffer, 2) = (byte)value; 72Unsafe.Add(ref outputBuffer, 3) = (byte)value; 76Unsafe.Add(ref outputBuffer, 3) = (byte)value; 78Unsafe.Add(ref outputBuffer, 2) = (byte)value; 80Unsafe.Add(ref outputBuffer, 1) = (byte)value; 100Unsafe.Add(ref outputBuffer, 1) = (byte)(value >> 16); 104Unsafe.Add(ref outputBuffer, 1) = (byte)value;

src\libraries\System.Private.CoreLib\src\System\Text\StringBuilder.cs (8)

340ref Unsafe.Add(ref result.GetRawStringData(), chunkOffset), 787Append(ref Unsafe.Add(ref value.GetRawStringData(), startIndex), count); 1238Debug.Assert(!Unsafe.IsNullRef(ref separator)); 2277ref char destination = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(chunkChars), chunkLength); 2283Unsafe.Add(ref destination, 1) = Unsafe.Add(ref value, 1); 2324new ReadOnlySpan<char>(ref Unsafe.Add(ref value, firstLength), restLength).CopyTo(m_ChunkChars); 2491value = ref Unsafe.Add(ref value, lengthToCopy);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf16Utility.Validation.cs (1)

417thisChar = Unsafe.ReadUnaligned<uint>(pInputBuffer);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8.cs (18)

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.cs (1)

31int index = (int)(void*)Unsafe.ByteOffset(ref *pUtf8Data, ref *pFirstInvalidByte);

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Helpers.cs (12)

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Transcoding.cs (36)

src\libraries\System.Private.CoreLib\src\System\Text\Unicode\Utf8Utility.Validation.cs (10)

src\libraries\System.Private.CoreLib\src\System\Text\UnicodeEncoding.cs (2)

746Unsafe.WriteUnaligned(longBytes, *longChars); 1402Unsafe.WriteUnaligned(longChars, *longBytes);

src\libraries\System.Private.CoreLib\src\System\Threading\Interlocked.cs (67)

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\Task.cs (2)

2385Unsafe.As<Task>(obj).InnerInvoke(); 6729return WhenAnyCore((ReadOnlySpan<TTask>)CollectionsMarshal.AsSpan(Unsafe.As<List<TTask>>(tasks)));

src\libraries\System.Private.CoreLib\src\System\Threading\Tasks\ValueTask.cs (12)

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadBlockingInfo.cs (4)

72t_first = (ThreadBlockingInfo*)Unsafe.AsPointer(ref this); 111return ((Lock)Unsafe.AsRef<object>(_objectPtr)).OwningOSThreadId; 144return ((Lock)Unsafe.AsRef<object>(_objectPtr)).OwningManagedThreadId; 173_blockingInfo.Push(Unsafe.AsPointer(ref _object), objectKind, timeoutMs);

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadInt64PersistentCounter.cs (2)

31Unsafe.As<ThreadLocalNode>(threadLocalCountObject).Increment(); 38Unsafe.As<ThreadLocalNode>(threadLocalCountObject).Add(count);

src\libraries\System.Private.CoreLib\src\System\Threading\ThreadPoolWorkQueue.cs (1)

1231Unsafe.As<IThreadPoolWorkItem>(workItem).Execute();

src\libraries\System.Private.CoreLib\src\System\Threading\Volatile.cs (43)

src\libraries\System.Private.CoreLib\src\System\TypedReference.cs (2)

26ref byte targetRef = ref Unsafe.NullRef<byte>(); 78internal bool IsNull => Unsafe.IsNullRef(ref _value) && _type == IntPtr.Zero;

src\libraries\System.Private.CoreLib\src\System\UInt128.cs (13)

851sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - Size); 854result = Unsafe.ReadUnaligned<UInt128>(ref sourceRef); 870result |= Unsafe.Add(ref sourceRef, i); 909result = Unsafe.ReadUnaligned<UInt128>(ref sourceRef); 926UInt128 part = Unsafe.Add(ref sourceRef, i); 1144Unsafe.WriteUnaligned(ref *(byte*)(pLeft + 0), (uint)(quotient._lower >> 00)); 1145Unsafe.WriteUnaligned(ref *(byte*)(pLeft + 1), (uint)(quotient._lower >> 32)); 1147Unsafe.WriteUnaligned(ref *(byte*)(pLeft + 2), (uint)(quotient._upper >> 00)); 1148Unsafe.WriteUnaligned(ref *(byte*)(pLeft + 3), (uint)(quotient._upper >> 32)); 1156Unsafe.WriteUnaligned(ref *(byte*)(pRight + 0), (uint)(divisor._lower >> 00)); 1157Unsafe.WriteUnaligned(ref *(byte*)(pRight + 1), (uint)(divisor._lower >> 32)); 1159Unsafe.WriteUnaligned(ref *(byte*)(pRight + 2), (uint)(divisor._upper >> 00)); 1160Unsafe.WriteUnaligned(ref *(byte*)(pRight + 3), (uint)(divisor._upper >> 32));

src\libraries\System.Private.CoreLib\src\System\UInt16.cs (3)

322sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(ushort)); 325result = Unsafe.ReadUnaligned<ushort>(ref sourceRef); 373result = Unsafe.ReadUnaligned<ushort>(ref sourceRef);

src\libraries\System.Private.CoreLib\src\System\UInt32.cs (5)

343sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(uint)); 346result = Unsafe.ReadUnaligned<uint>(ref sourceRef); 362result |= Unsafe.Add(ref sourceRef, i); 401result = Unsafe.ReadUnaligned<uint>(ref sourceRef); 418uint part = Unsafe.Add(ref sourceRef, i);

src\libraries\System.Private.CoreLib\src\System\UInt64.cs (5)

342sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(ulong)); 345result = Unsafe.ReadUnaligned<ulong>(ref sourceRef); 361result |= Unsafe.Add(ref sourceRef, i); 400result = Unsafe.ReadUnaligned<ulong>(ref sourceRef); 417ulong part = Unsafe.Add(ref sourceRef, i);

src\libraries\System.Private.CoreLib\src\System\UIntPtr.cs (23)

src\libraries\System.Private.CoreLib\src\System\Version.cs (2)

252((uint)value).TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(destination), out valueCharsWritten) : 253((uint)value).TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(destination), out valueCharsWritten, default, CultureInfo.InvariantCulture);

src\libraries\System.Private.CoreLib\src\System\WeakReference.T.cs (2)

144target = Unsafe.As<T?>(ComAwareWeakReference.GetTarget(th)); 154target = Unsafe.As<T?>(GCHandle.InternalGet(th));

src\System\Array.CoreCLR.cs (56)

src\System\Buffer.CoreCLR.cs (1)

34Memmove(ref *(pDest + (uint)destIndex), ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(src), (nint)(uint)srcIndex /* force zero-extension */), (uint)len);

src\System\Delegate.CoreCLR.cs (1)

438return Unsafe.As<MulticastDelegate>(RuntimeTypeHandle.InternalAlloc(type));

src\System\Enum.CoreCLR.cs (1)

129=> ref Unsafe.As<RuntimeType.IGenericCacheEntry?, EnumInfo<TStorage>?>(ref compositeEntry._enumInfo);

src\System\GC.CoreCLR.cs (1)

879ref GCConfigurationContext context = ref Unsafe.As<byte, GCConfigurationContext>(ref *(byte*)configurationContext);

src\System\MulticastDelegate.CoreCLR.cs (2)

57MulticastDelegate d = Unsafe.As<MulticastDelegate>(obj); 170MulticastDelegate result = Unsafe.As<MulticastDelegate>(RuntimeTypeHandle.InternalAllocNoChecks((RuntimeType)GetType()));

src\System\Reflection\RuntimeCustomAttributeData.cs (1)

1540int data = Unsafe.ReadUnaligned<int>((void*)blobStart);

src\System\Reflection\TypeNameResolver.CoreCLR.cs (1)

177assembly = RuntimeAssembly.InternalLoad(assemblyName, ref Unsafe.NullRef<StackCrawlMark>(),

src\System\Runtime\CompilerServices\CastHelpers.cs (7)

422ref object? element = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index); 439ref object? element = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index); 592SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, IntPtr>(ref destPtr), typeMT->GetNumInstanceFieldBytesIfContainsGCPointers() / (nuint)sizeof(IntPtr)); 603Unsafe.As<byte, bool>(ref destPtr) = true; 604ref byte dst = ref Unsafe.Add(ref destPtr, typeMT->NullableValueAddrOffset); 623if (!Unsafe.As<byte, bool>(ref nullableData)) 631ref byte srcData = ref Unsafe.Add(ref nullableData, srcMT->NullableValueAddrOffset);

src\System\Runtime\CompilerServices\RuntimeHelpers.CoreCLR.cs (19)

68new ReadOnlySpan<ushort>(ref Unsafe.As<byte, ushort>(ref src), array.Length), 69new Span<ushort>(ref Unsafe.As<byte, ushort>(ref dst), array.Length)); 73new ReadOnlySpan<uint>(ref Unsafe.As<byte, uint>(ref src), array.Length), 74new Span<uint>(ref Unsafe.As<byte, uint>(ref dst), array.Length)); 78new ReadOnlySpan<ulong>(ref Unsafe.As<byte, ulong>(ref src), array.Length), 79new Span<ulong>(ref Unsafe.As<byte, ulong>(ref dst), array.Length)); 390ref Unsafe.As<RawData>(obj).Data; 400rawSize += (uint)Unsafe.As<RawArrayData>(obj).Length * (nuint)pMT->ComponentSize; 421return ref Unsafe.As<byte, int>(ref Unsafe.As<RawArrayData>(array).Data); 575/// This API returns the same value as <see cref="Unsafe.SizeOf{T}"/> for the type that <paramref name="type"/> represents. 628private MethodDescChunk* GetMethodDescChunk() => (MethodDescChunk*)(((byte*)Unsafe.AsPointer<MethodDesc>(ref this)) - (sizeof(MethodDescChunk) + ChunkIndex * sizeof(IntPtr))); 946return *(RuntimeType*)Unsafe.AsPointer(ref _exposedClassObject); 966return ref Unsafe.AsRef<byte>((byte*)((nuint)p & ~(nuint)DynamicStaticsInfo.ISCLASSNOTINITED)); 1043return *(RuntimeType*)Unsafe.AsPointer(ref ExposedClassObjectRaw); 1054return ref Unsafe.Subtract(ref Unsafe.As<MethodTableAuxiliaryData, DynamicStaticsInfo>(ref this), 1); 1060return ref Unsafe.Subtract(ref Unsafe.As<MethodTableAuxiliaryData, ThreadStaticsInfo>(ref this), 1);

src\System\Runtime\CompilerServices\StaticsHelpers.cs (9)

35if ((((nuint)Unsafe.AsPointer(ref nonGCStaticBase)) & DynamicStaticsInfo.ISCLASSNOTINITED) != 0) 46if ((((nuint)Unsafe.AsPointer(ref nonGCStaticBase)) & DynamicStaticsInfo.ISCLASSNOTINITED) != 0) 65if ((((nuint)Unsafe.AsPointer(ref gcStaticBase)) & DynamicStaticsInfo.ISCLASSNOTINITED) != 0) 76if ((((nuint)Unsafe.AsPointer(ref gcStaticBase)) & DynamicStaticsInfo.ISCLASSNOTINITED) != 0) 91return ref Unsafe.Subtract(ref RuntimeHelpers.GetRawData(obj), sizeof(MethodTable*)); 108return Unsafe.As<IntPtr, object[]>(ref _nonCollectibleTlsArrayData_private); 183object? threadStaticObjectNonCollectible = Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(t_ThreadStatics->NonCollectibleTlsArrayData), indexOffset - ThreadLocalData.NUMBER_OF_TLSOFFSETS_NOT_USED_IN_NONCOLLECTIBLE_ARRAY); 192return ref Unsafe.Add(ref Unsafe.AsRef<byte>(t_ThreadStatics), indexOffset);

src\System\Runtime\InteropServices\ComWrappers.cs (1)

97return Unsafe.As<T>(GCHandle.InternalGet(comInstance->GcHandle));

src\System\Runtime\InteropServices\Marshal.CoreCLR.cs (5)

263structMarshalStub(ref structure.GetRawData(), (byte*)ptr, MarshalOperation.Cleanup, ref Unsafe.NullRef<CleanupWorkListElement?>()); 266structMarshalStub(ref structure.GetRawData(), (byte*)ptr, MarshalOperation.Marshal, ref Unsafe.NullRef<CleanupWorkListElement?>()); 291structMarshalStub(ref structure.GetRawData(), (byte*)ptr, MarshalOperation.Unmarshal, ref Unsafe.NullRef<CleanupWorkListElement?>()); 325structMarshalStub(ref Unsafe.NullRef<byte>(), (byte*)ptr, MarshalOperation.Cleanup, ref Unsafe.NullRef<CleanupWorkListElement?>());

src\System\Runtime\InteropServices\MemoryMarshal.CoreCLR.cs (2)

44return ref Unsafe.AddByteOffset(ref Unsafe.As<RawData>(array).Data, (nuint)RuntimeHelpers.GetMethodTable(array)->BaseSize - (nuint)(2 * sizeof(IntPtr)));

src\System\RuntimeHandles.cs (3)

1547Debug.Assert(!Unsafe.IsNullRef(ref fieldDataRef.Get())); 1554Debug.Assert(!Unsafe.IsNullRef(ref target)); 1556return ref Unsafe.AddByteOffset(ref target, offset);

src\System\RuntimeType.BoxCache.cs (3)

72return Unsafe.As<byte, object>(ref data); 77byte maybeNullableHasValue = Unsafe.ReadUnaligned<byte>(ref source); 85source = ref Unsafe.Add(ref source, _nullableValueOffset);

src\System\RuntimeType.CoreCLR.cs (2)

2424return Unsafe.As<RuntimeTypeCache>(cache); 2441return Unsafe.As<RuntimeTypeCache>(cache);

src\System\String.CoreCLR.cs (1)

41SpanHelpers.Memmove(ref *(byte*)dest, ref Unsafe.As<char, byte>(ref src.GetRawStringData()), (nuint)len);

src\System\StubHelpers.cs (3)

510if (Unsafe.IsNullRef(ref cleanupWorkList)) 1541structMarshalStub(ref obj.GetRawData(), pNative, MarshalOperation.Unmarshal, ref Unsafe.NullRef<CleanupWorkListElement?>()); 1560structMarshalStub(ref obj.GetRawData(), pNative, MarshalOperation.Cleanup, ref Unsafe.NullRef<CleanupWorkListElement?>());

src\System\Threading\Interlocked.CoreCLR.cs (3)

97if (Unsafe.IsNullRef(ref location1)) 163if (Unsafe.IsNullRef(ref location1)) 228CompareExchange(ref Unsafe.AsRef(in location), 0, 0);

src\System\Threading\Thread.CoreCLR.cs (1)

454return (StaticsHelpers.ThreadLocalData*)(((byte*)Unsafe.AsPointer(ref DirectOnThreadLocalData.pNativeThread)) - sizeof(StaticsHelpers.ThreadLocalData));

src\System\TypedReference.CoreCLR.cs (1)

69result = Unsafe.As<byte, object>(ref value._value);

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);