MemoryMarshal

Internal\Runtime\Augments\RuntimeAugments.cs (2)

157ref byte element = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(array), (nuint)flattenedIndex * array.ElementSize); 164ref object element = ref Unsafe.Add(ref Unsafe.As<byte, object>(ref MemoryMarshal.GetArrayDataReference(array)), flattenedIndex);

src\runtime\src\coreclr\nativeaot\Runtime.Base\src\System\Runtime\TypeCast.cs (2)

764ref object? element = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index); 795ref object? element = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index);

src\runtime\src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadDir.cs (1)

38? MemoryMarshal.CreateReadOnlySpanFromNullTerminated(Name)

src\runtime\src\libraries\Common\src\Interop\Unix\System.Native\Interop.ReadLink.cs (1)

43int resultLength = ReadLink(path, ref MemoryMarshal.GetReference(spanBuffer), spanBuffer.Length);

src\runtime\src\libraries\Common\src\System\HexConverter.cs (4)

122ref byte srcRef = ref MemoryMarshal.GetReference(source); 123ref TChar destRef = ref MemoryMarshal.GetReference(destination); 324ref TChar srcRef = ref MemoryMarshal.GetReference(source); 325ref byte destRef = ref MemoryMarshal.GetReference(destination);

src\runtime\src\libraries\Common\src\System\Number.Formatting.Common.cs (5)

328fixed (char* pFormat = &MemoryMarshal.GetReference(format)) 527fixed (char* pFormat = &MemoryMarshal.GetReference(format)) 793fixed (TChar* spanPtr = &MemoryMarshal.GetReference(vlb.AppendSpan(bufferSize))) 880r.EncodeToUtf8(MemoryMarshal.AsBytes(vlb.AppendSpan(r.Utf8SequenceLength))); 1135fixed (char* pFormat = &MemoryMarshal.GetReference(format))

src\runtime\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\runtime\src\libraries\Common\src\System\Number.Parsing.Common.cs (2)

285fixed (TChar* stringPointer = &MemoryMarshal.GetReference(value)) 344fixed (TChar* stringPointer = &MemoryMarshal.GetReference(value))

src\runtime\src\libraries\Common\src\System\Runtime\InteropServices\SpanOfCharAsUtf8StringMarshaller.cs (1)

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

src\runtime\src\libraries\Common\src\System\Text\ValueStringBuilder.cs (1)

75return ref MemoryMarshal.GetReference(_chars);

src\runtime\src\libraries\System.Private.CoreLib\src\Microsoft\Win32\SafeHandles\SafeFileHandle.ThreadPoolValueTaskSource.cs (1)

98Memory<byte> writableSingleSegment = MemoryMarshal.AsMemory(_singleSegment);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Array.cs (30)

src\runtime\src\libraries\System.Private.CoreLib\src\System\BitConverter.cs (28)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffer.cs (4)

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;

src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.ReadBigEndian.cs (56)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.ReadLittleEndian.cs (56)

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.WriteBigEndian.cs (56)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Binary\BinaryPrimitives.WriteLittleEndian.cs (56)

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

414Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(arrays), count) = array; // arrays[count] = array, but avoiding stelemref

src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Decoder.cs (1)

175DecodeFrom(default(Base64DecoderChar), MemoryMarshal.Cast<char, ushort>(source), destination,

src\runtime\src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Base64Encoder.cs (1)

162EncodeTo(default(Base64EncoderChar), source, MemoryMarshal.Cast<char, ushort>(destination), out bytesConsumed, out charsWritten, isFinalBlock);

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

34fixed (T* srcBytes = &MemoryMarshal.GetReference(source)) 35fixed (byte* destBytes = &MemoryMarshal.GetReference(bytes)) 129ref sbyte decodingMap = ref MemoryMarshal.GetReference(decoder.DecodingMap); 345fixed (byte* bufferBytes = &MemoryMarshal.GetReference(buffer)) 356ref sbyte decodingMap = ref MemoryMarshal.GetReference(decoder.DecodingMap);

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

31fixed (byte* srcBytes = &MemoryMarshal.GetReference(source)) 32fixed (T* destBytes = &MemoryMarshal.GetReference(destination)) 83ref byte encodingMap = ref MemoryMarshal.GetReference(encoder.EncodingMap); 588fixed (byte* bufferBytes = &MemoryMarshal.GetReference(buffer)) 601ref byte encodingMap = ref MemoryMarshal.GetReference(encoder.EncodingMap);

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

202DecodeFrom(default(Base64UrlDecoderChar), MemoryMarshal.Cast<char, ushort>(source), destination,

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

109EncodeTo(default(Base64UrlEncoderChar), source, MemoryMarshal.Cast<char, ushort>(destination), out bytesConsumed, out charsWritten, isFinalBlock);

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

55ulong powerOf10 = Unsafe.Add(ref MemoryMarshal.GetReference(powersOf10), elementOffset);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Collections\BitArray.cs (16)

95MemoryMarshal.AsBytes(array).CopyTo(_array); 99BinaryPrimitives.ReverseEndianness(array, MemoryMarshal.Cast<byte, int>((Span<byte>)_array)); 123MemoryMarshal.Cast<byte, int>((Span<byte>)_array)[(int)index] &= ReverseIfBE((1 << (int)extraBits) - 1); 172ref byte arrayRef = ref MemoryMarshal.GetArrayDataReference(_array); 173ReadOnlySpan<byte> valuesAsBytes = MemoryMarshal.AsBytes(values.AsSpan()); 257MemoryMarshal.AsBytes(values).CopyTo(_array); 261BinaryPrimitives.ReverseEndianness(values, MemoryMarshal.Cast<byte, int>((Span<byte>)_array)); 449Span<int> thisRemaining = MemoryMarshal.Cast<byte, int>(((Span<byte>)thisArray).Slice(i, roundedBytesRemaining)); 450Span<int> valueRemaining = MemoryMarshal.Cast<byte, int>(((Span<byte>)valueArray).Slice(i, roundedBytesRemaining)); 464ref byte left = ref MemoryMarshal.GetArrayDataReference(thisArray); 465ref byte right = ref MemoryMarshal.GetArrayDataReference(valueArray); 525Span<int> intSpan = MemoryMarshal.Cast<byte, int>((Span<byte>)_array); 588Span<int> intSpan = MemoryMarshal.Cast<byte, int>((Span<byte>)_array); 691Span<int> source = MemoryMarshal.Cast<byte, int>((Span<byte>)_array).Slice(0, intLength); 743Span<int> in32Span = MemoryMarshal.Cast<byte, int>((Span<byte>)_array); 898foreach (int i in MemoryMarshal.Cast<byte, int>(_array))

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

463ref T zeroRef = ref MemoryMarshal.GetReference(keys); 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\runtime\src\libraries\System.Private.CoreLib\src\System\Collections\Generic\RandomizedStringEqualityComparer.cs (2)

90ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(alternate)), 135ref MemoryMarshal.GetReference(alternate),

src\runtime\src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventPipePayloadDecoder.cs (3)

121charPayload = MemoryMarshal.Cast<byte, char>(payload); 126charPayload = MemoryMarshal.Cast<byte, char>(payload.Slice(0, byteCount - 2)); 129decodedFields[i] = BitConverter.IsLittleEndian ? new string(charPayload) : Encoding.Unicode.GetString(MemoryMarshal.Cast<char, byte>(charPayload));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Enum.cs (2)

2254ReadOnlySpan<byte> rawData = MemoryMarshal.AsBytes(new ReadOnlySpan<long>(ref value)); 2265return RuntimeHelpers.Box(ref MemoryMarshal.GetReference(rawData), type)!;

src\runtime\src\libraries\System.Private.CoreLib\src\System\GCMemoryInfo.cs (2)

80internal ReadOnlySpan<GCGenerationInfo> GenerationInfoAsSpan => MemoryMarshal.CreateReadOnlySpan(ref _generationInfo0, 5); 85internal ReadOnlySpan<TimeSpan> PauseDurationsAsSpan => MemoryMarshal.CreateReadOnlySpan(ref _pauseDuration0, 2);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\CalendarData.Icu.cs (1)

445ReadOnlySpan<char> calendarStringSpan = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(calendarStringPtr);

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

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Icu.cs (26)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\CompareInfo.Nls.cs (12)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormat.cs (17)

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

214Rune.DecodeLastFromUtf8(MemoryMarshal.AsBytes(outputBuffer.AsSpan()), out Rune value, out int bytesConsumed);

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

219Ordinal.EqualsIgnoreCase(ref MemoryMarshal.GetReference(input), ref MemoryMarshal.GetReference(output), input.Length))

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

230fixed (char* pSource = &MemoryMarshal.GetReference(source)) 231fixed (char* pValue = &MemoryMarshal.GetReference(value)) 292fixed (char* pSource = &MemoryMarshal.GetReference(source)) 293fixed (char* pValue = &MemoryMarshal.GetReference(value))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Icu.cs (1)

68fixed (char* pDest = &MemoryMarshal.GetReference(buffer))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Nls.cs (1)

63fixed (char* pDest = &MemoryMarshal.GetReference(buffer))

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

355ref char valueRef = ref MemoryMarshal.GetReference(value); 365ref char searchSpace = ref MemoryMarshal.GetReference(source);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Globalization\Ordinal.Utf8.cs (4)

61ReadOnlySpan<byte> spanA = MemoryMarshal.CreateReadOnlySpan(ref strA, lengthA); 62ReadOnlySpan<byte> spanB = MemoryMarshal.CreateReadOnlySpan(ref strB, lengthB); 371ReadOnlySpan<byte> spanA = MemoryMarshal.CreateReadOnlySpan(ref source, sourceLength); 372ReadOnlySpan<byte> spanB = MemoryMarshal.CreateReadOnlySpan(ref prefix, prefixLength);

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

285fixed (char* pSource = &MemoryMarshal.GetReference(source)) 286fixed (char* pValue = &MemoryMarshal.GetReference(value)) 349fixed (char* pSource = &MemoryMarshal.GetReference(source)) 350fixed (char* pValue = &MemoryMarshal.GetReference(value))

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

264fixed (char* pSource = &MemoryMarshal.GetReference(source)) 265fixed (char* pDestination = &MemoryMarshal.GetReference(destination))

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

232fixed (TChar* dest = &MemoryMarshal.GetReference(destination))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Guid.cs (17)

72this = MemoryMarshal.Read<Guid>(b); 89this = MemoryMarshal.Read<Guid>(b); 529Span<byte> bytes = MemoryMarshal.AsBytes(new Span<GuidResult>(ref result)); 617Span<byte> bytes = MemoryMarshal.AsBytes(new Span<GuidResult>(ref result)); 1003MemoryMarshal.Write(g, in this); 1008Guid guid = new Guid(MemoryMarshal.AsBytes(new ReadOnlySpan<Guid>(in this)), false); 1009MemoryMarshal.Write(g, in guid); 1021MemoryMarshal.Write(g, in this); 1026Guid guid = new Guid(MemoryMarshal.AsBytes(new ReadOnlySpan<Guid>(in this)), bigEndian); 1027MemoryMarshal.Write(g, in guid); 1040MemoryMarshal.Write(destination, in this); 1045Guid guid = new Guid(MemoryMarshal.AsBytes(new ReadOnlySpan<Guid>(in this)), false); 1046MemoryMarshal.Write(destination, in guid); 1062MemoryMarshal.Write(destination, in this); 1067Guid guid = new Guid(MemoryMarshal.AsBytes(new ReadOnlySpan<Guid>(in this)), bigEndian); 1068MemoryMarshal.Write(destination, in guid); 1337fixed (TChar* guidChars = &MemoryMarshal.GetReference(destination))

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\Enumeration\FileSystemEntry.Unix.cs (1)

104Span<char> buffer = MemoryMarshal.CreateSpan(ref _fileNameBuffer._char0, DecodedNameBufferLength);

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

410MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> destinationArray) ? 693if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> sourceArray))

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\PinnedBufferMemoryStream.cs (1)

26fixed (byte* ptr = &MemoryMarshal.GetReference((Span<byte>)array))

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\RandomAccess.Unix.cs (4)

27fixed (byte* bufPtr = &MemoryMarshal.GetReference(buffer)) 75fixed (Interop.Sys.IOVector* pinnedVectors = &MemoryMarshal.GetReference(vectors)) 114fixed (byte* bufPtr = &MemoryMarshal.GetReference(buffer)) 199fixed (Interop.Sys.IOVector* pinnedVectors = &MemoryMarshal.GetReference(left))

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

311if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> array)) 734if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> array))

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\StreamWriter.cs (1)

427fixed (char* bufferPtr = &MemoryMarshal.GetReference(buffer))

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

275new ValueTask<int>(MemoryMarshal.TryGetArray(buffer, out ArraySegment<char> array) ? 305new ValueTask<int>(MemoryMarshal.TryGetArray(buffer, out ArraySegment<char> array) ?

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

674MemoryMarshal.TryGetArray(buffer, out ArraySegment<char> array) ? 769MemoryMarshal.TryGetArray(buffer, out ArraySegment<char> array) ?

src\runtime\src\libraries\System.Private.CoreLib\src\System\IO\UnmanagedMemoryStream.cs (6)

394SpanHelpers.Memmove(ref MemoryMarshal.GetReference(buffer), ref *(pointer + pos + _offset), (nuint)nInt); 406SpanHelpers.Memmove(ref MemoryMarshal.GetReference(buffer), ref *(_mem + pos), (nuint)nInt); 468MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> destinationArray) ? 673SpanHelpers.Memmove(ref *(pointer + pos + _offset), ref MemoryMarshal.GetReference(buffer), (nuint)buffer.Length); 685SpanHelpers.Memmove(ref *(_mem + pos), ref MemoryMarshal.GetReference(buffer), (nuint)buffer.Length); 734if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> sourceArray))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Marvin.cs (1)

23public static int ComputeHash32(ReadOnlySpan<byte> data, ulong seed) => ComputeHash32(ref MemoryMarshal.GetReference(data), (uint)data.Length, (uint)seed, (uint)(seed >> 32));

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

94int hash = ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(scratch)), (uint)charsWritten * 2, p0, p1);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Memory.cs (4)

304refToReturn = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject)); 317refToReturn = ref MemoryMarshal.GetReference(memoryManagerSpan); 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);

src\runtime\src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.cs (203)

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\MemoryExtensions.Globalization.Utf8.cs (4)

24return Ordinal.EqualsIgnoreCaseUtf8(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length); 75return Ordinal.StartsWithIgnoreCaseUtf8(ref MemoryMarshal.GetReference(span), span.Length, ref MemoryMarshal.GetReference(value), value.Length);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (1)

349Span<byte> utf8Bytes = MemoryMarshal.AsBytes(dest).Slice(dest.Length * 2 - state.byteCount);

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

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

574ref MemoryMarshal.GetReference(TrailingZeroCountDeBruijn), 871ref uint lookupTable = ref MemoryMarshal.GetArrayDataReference(s_crcTable); 879ref uint lookupTable = ref MemoryMarshal.GetArrayDataReference(s_crcTable); 890ref uint lookupTable = ref MemoryMarshal.GetArrayDataReference(s_crcTable);

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

821return Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values)));

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

97this = Unsafe.ReadUnaligned<Vector<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 115this = Unsafe.ReadUnaligned<Vector<T>>(ref MemoryMarshal.GetReference(values)); 665Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), this); 679Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), this); 786Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), this); 801Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), this);

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

411return Unsafe.ReadUnaligned<Vector2>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 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\runtime\src\libraries\System.Private.CoreLib\src\System\Numerics\Vector3.cs (3)

446return Unsafe.ReadUnaligned<Vector3>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 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\runtime\src\libraries\System.Private.CoreLib\src\System\Random.cs (1)

646Shuffle(new Span<T>(ref MemoryMarshal.GetArrayDataReference(values), values.Length));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Random.Xoshiro256StarStarImpl.cs (1)

142MemoryMarshal.Write(buffer, BitOperations.RotateLeft(s1 * 5, 7) * 9);

src\runtime\src\libraries\System.Private.CoreLib\src\System\ReadOnlyMemory.cs (4)

226refToReturn = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject)); 239refToReturn = ref MemoryMarshal.GetReference(memoryManagerSpan); 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);

src\runtime\src\libraries\System.Private.CoreLib\src\System\ReadOnlySpan.cs (2)

50_reference = ref MemoryMarshal.GetArrayDataReference(array); 84_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */);

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

296ref byte dst = ref MemoryMarshal.GetReference(buffer); 323ref byte dst = ref MemoryMarshal.GetReference(buffer);

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

64ref MemoryMarshal.GetArrayDataReference(dest), 65ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), offset),

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\CollectionsMarshal.cs (1)

39span = new Span<T>(ref MemoryMarshal.GetArrayDataReference(items), size);

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

142return (IntPtr)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<Array>(target)));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\GCHandleExtensions.cs (1)

38return (T*)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(array));

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

169void* pRawData = Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(arr)); 178void* pRawData = Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(arr));

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

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

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

181public ref TUnmanagedElement GetPinnableReference() => ref MemoryMarshal.GetReference(_span); 212return ref MemoryMarshal.GetArrayDataReference(array);

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

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

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

182public ref TUnmanagedElement GetPinnableReference() => ref MemoryMarshal.GetReference(_span); 213return ref MemoryMarshal.GetArrayDataReference(array);

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

19/// A <see cref="ReadOnlySpan{T}"/> marshalled with this marshaller will match the semantics of <see cref="MemoryMarshal.GetReference{T}(ReadOnlySpan{T})"/>. 45if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 110if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 147public ref TUnmanagedElement GetPinnableReference() => ref MemoryMarshal.GetReference(_span); 173return ref MemoryMarshal.GetReference(managed);

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

19/// A <see cref="Span{T}"/> marshalled with this marshaller will match the semantics of <see cref="MemoryMarshal.GetReference{T}(Span{T})"/>. 39if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 143if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 179public ref TUnmanagedElement GetPinnableReference() => ref MemoryMarshal.GetReference(_span); 205return ref MemoryMarshal.GetReference(managed);

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

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\SafeBuffer.cs (2)

246ref T structure = ref MemoryMarshal.GetReference(buffer); 335ref T structure = ref MemoryMarshal.GetReference(data);

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

207TSelf.StoreUnsafe(vector, ref MemoryMarshal.GetReference(destination)); 257return TSelf.LoadUnsafe(ref MemoryMarshal.GetReference(values)); 792TSelf.StoreUnsafe(vector, ref MemoryMarshal.GetReference(destination));

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

790Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector); 1059return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 3777Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);

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

797Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector); 1060return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 3714Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);

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

708Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector); 955return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 3685Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);

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

749Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector); 1035return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 3774Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);

src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Any1CharPackedIgnoreCaseSearchValues.cs (2)

37PackedSpanHelpers.IndexOfAnyIgnoreCase(ref MemoryMarshal.GetReference(span), _lowerCase, span.Length); 42PackedSpanHelpers.IndexOfAnyExceptIgnoreCase(ref MemoryMarshal.GetReference(span), _lowerCase, span.Length);

src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Any1CharPackedSearchValues.cs (2)

27PackedSpanHelpers.IndexOf(ref MemoryMarshal.GetReference(span), _e0, span.Length); 32PackedSpanHelpers.IndexOfAnyExcept(ref MemoryMarshal.GetReference(span), _e0, span.Length);

src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Any2CharPackedIgnoreCaseSearchValues.cs (4)

44PackedSpanHelpers.IndexOfAnyIgnoreCase(ref MemoryMarshal.GetReference(span), _e0, _e1, span.Length); 49PackedSpanHelpers.IndexOfAnyExceptIgnoreCase(ref MemoryMarshal.GetReference(span), _e0, _e1, span.Length); 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\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Any2CharPackedSearchValues.cs (2)

27PackedSpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), _e0, _e1, span.Length); 32PackedSpanHelpers.IndexOfAnyExcept(ref MemoryMarshal.GetReference(span), _e0, _e1, span.Length);

src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Any3CharPackedSearchValues.cs (2)

27PackedSpanHelpers.IndexOfAny(ref MemoryMarshal.GetReference(span), _e0, _e1, _e2, span.Length); 32PackedSpanHelpers.IndexOfAnyExcept(ref MemoryMarshal.GetReference(span), _e0, _e1, _e2, span.Length);

src\runtime\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\runtime\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\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\AnyByteSearchValues.cs (6)

32ref MemoryMarshal.GetReference(span), span.Length, ref _state); 40ref MemoryMarshal.GetReference(span), span.Length, ref _state); 48ref MemoryMarshal.GetReference(span), span.Length, ref _state); 56ref MemoryMarshal.GetReference(span), span.Length, ref _state); 64ref MemoryMarshal.GetReference(span), span.Length, ref _state); 72ref MemoryMarshal.GetReference(span), span.Length, ref _state);

src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\AsciiByteSearchValues.cs (6)

48ref MemoryMarshal.GetReference(span), span.Length, ref _state); 56ref MemoryMarshal.GetReference(span), span.Length, ref _state); 64ref MemoryMarshal.GetReference(span), span.Length, ref _state); 72ref MemoryMarshal.GetReference(span), span.Length, ref _state); 80ref MemoryMarshal.GetReference(span), span.Length, ref _state); 88ref MemoryMarshal.GetReference(span), span.Length, ref _state);

src\runtime\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\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\BitmapCharSearchValues.cs (4)

56IndexOfAny<IndexOfAnyAsciiSearcher.DontNegate>(ref MemoryMarshal.GetReference(span), span.Length); 60IndexOfAny<IndexOfAnyAsciiSearcher.Negate>(ref MemoryMarshal.GetReference(span), span.Length); 64LastIndexOfAny<IndexOfAnyAsciiSearcher.DontNegate>(ref MemoryMarshal.GetReference(span), span.Length); 68LastIndexOfAny<IndexOfAnyAsciiSearcher.Negate>(ref MemoryMarshal.GetReference(span), span.Length);

src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticCharSearchValues.cs (4)

26ProbabilisticMap.IndexOfAny<SearchValues.TrueConst>(ref MemoryMarshal.GetReference(span), span.Length, ref _map); 29ProbabilisticMapState.IndexOfAnySimpleLoop<SearchValues.TrueConst, IndexOfAnyAsciiSearcher.Negate>(ref MemoryMarshal.GetReference(span), span.Length, ref _map); 32ProbabilisticMap.LastIndexOfAny<SearchValues.TrueConst>(ref MemoryMarshal.GetReference(span), span.Length, ref _map); 35ProbabilisticMapState.LastIndexOfAnySimpleLoop<SearchValues.TrueConst, IndexOfAnyAsciiSearcher.Negate>(ref MemoryMarshal.GetReference(span), span.Length, ref _map);

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

108ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(values)),

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

88return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(hashEntries), (nuint)offset) == value;

src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticWithAsciiCharSearchValues.cs (10)

src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\RangeCharSearchValues.cs (4)

43? PackedSpanHelpers.IndexOfAnyInRange(ref MemoryMarshal.GetReference(span), _lowInclusive, _rangeInclusive, span.Length) 45ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(span)), 53? PackedSpanHelpers.IndexOfAnyExceptInRange(ref MemoryMarshal.GetReference(span), _lowInclusive, _rangeInclusive, span.Length) 55ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(span)),

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

86ReadOnlySpan<short> shortValues = MemoryMarshal.Cast<char, short>(values);

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

202ref char searchSpace = ref MemoryMarshal.GetReference(span); 254ref char searchSpace = ref MemoryMarshal.GetReference(span); 306ref char searchSpace = ref MemoryMarshal.GetReference(span); 361ref char searchSpace = ref MemoryMarshal.GetReference(span); 431ref char searchSpace = ref MemoryMarshal.GetReference(span); 486ref char searchSpace = ref MemoryMarshal.GetReference(span); 547offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref matchRef) / 2); 594offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref matchRef) / 2); 639offsetFromStart = (int)((nuint)Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref matchRef) / 2);

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

81ref AhoCorasickNode nodes = ref MemoryMarshal.GetArrayDataReference(_nodes); 100ref Unsafe.As<char, short>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i)), 123char c = TCaseSensitivity.TransformInput(Unsafe.Add(ref MemoryMarshal.GetReference(span), i)); 186ref AhoCorasickNode nodes = ref MemoryMarshal.GetArrayDataReference(_nodes); 209ref Unsafe.As<char, short>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i)), 242c = Unsafe.Add(ref MemoryMarshal.GetReference(span), i); 247char.IsLowSurrogate(lowSurrogate = Unsafe.Add(ref MemoryMarshal.GetReference(span), i + 1)))

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

114ref char current = ref MemoryMarshal.GetReference(span); 120ref char end = ref Unsafe.Add(ref MemoryMarshal.GetReference(span), (uint)(span.Length - hashLength)); 129ref string[]? bucketsRef = ref MemoryMarshal.GetArrayDataReference(_buckets); 137int startOffset = (int)((nuint)Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref current) / sizeof(char));

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

23ValidateReadPosition(MemoryMarshal.CreateReadOnlySpan(ref searchSpaceStart, searchSpaceLength), ref searchSpace, offset); 31nint currentByteOffset = Unsafe.ByteOffset(ref MemoryMarshal.GetReference(span), ref searchSpace);

src\runtime\src\libraries\System.Private.CoreLib\src\System\SearchValues\Strings\SingleStringSearchValuesPackedThreeChars.cs (1)

79IndexOf(ref MemoryMarshal.GetReference(span), span.Length);

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

74IndexOf(ref MemoryMarshal.GetReference(span), span.Length);

src\runtime\src\libraries\System.Private.CoreLib\src\System\Span.cs (2)

52_reference = ref MemoryMarshal.GetArrayDataReference(array); 89_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */);

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

20return BinarySearch(ref MemoryMarshal.GetReference(span), span.Length, comparable);

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

349=> SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(strA), strA.Length, ref MemoryMarshal.GetReference(strB), strB.Length); 717return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(value)), (uint)value.Length * 2 /* in bytes, not chars */, (uint)seed, (uint)(seed >> 32)); 750return Marvin.ComputeHash32OrdinalIgnoreCase(ref MemoryMarshal.GetReference(value), value.Length /* in chars, not bytes */, (uint)seed, (uint)(seed >> 32)); 804fixed (char* src = &MemoryMarshal.GetReference(span)) 915fixed (char* src = &MemoryMarshal.GetReference(span))

src\runtime\src\libraries\System.Private.CoreLib\src\System\String.cs (6)

86source: ref MemoryMarshal.GetArrayDataReference(value)); 112source: ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(value), startIndex)); 317Buffer.Memmove(ref result._firstChar, ref MemoryMarshal.GetReference(value), (uint)value.Length); 427destination: ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), destinationIndex), 472destination: ref MemoryMarshal.GetArrayDataReference(chars), 496destination: ref MemoryMarshal.GetArrayDataReference(chars),

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

2104ref char source = ref MemoryMarshal.GetReference(sourceSpan); 2473fixed (char* pTrimChars = &MemoryMarshal.GetReference(trimChars)) 2540fixed (char* pTrimChars = &MemoryMarshal.GetReference(trimChars))

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

42=> ChangeCase<ushort, ushort, ToUpperConversion>(MemoryMarshal.Cast<char, ushort>(source), MemoryMarshal.Cast<char, ushort>(destination), out charsWritten); 54=> ChangeCase<byte, ushort, ToUpperConversion>(source, MemoryMarshal.Cast<char, ushort>(destination), out charsWritten); 66=> ChangeCase<ushort, byte, ToUpperConversion>(MemoryMarshal.Cast<char, ushort>(source), destination, out bytesWritten); 92=> ChangeCase<ushort, ushort, ToLowerConversion>(MemoryMarshal.Cast<char, ushort>(source), MemoryMarshal.Cast<char, ushort>(destination), out charsWritten); 104=> ChangeCase<byte, ushort, ToLowerConversion>(source, MemoryMarshal.Cast<char, ushort>(destination), out charsWritten); 116=> ChangeCase<ushort, byte, ToLowerConversion>(MemoryMarshal.Cast<char, ushort>(source), destination, out bytesWritten); 136=> ChangeCase<ushort, ToLowerConversion>(MemoryMarshal.Cast<char, ushort>(value), out charsWritten); 156=> ChangeCase<ushort, ToUpperConversion>(MemoryMarshal.Cast<char, ushort>(value), out charsWritten); 163if (MemoryMarshal.AsBytes(source).Overlaps(MemoryMarshal.AsBytes(destination))) 182fixed (TFrom* pSource = &MemoryMarshal.GetReference(source)) 183fixed (TTo* pDestination = &MemoryMarshal.GetReference(destination)) 197fixed (T* pBuffer = &MemoryMarshal.GetReference(buffer))

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

22IsValidCore(ref MemoryMarshal.GetReference(value), value.Length); 32IsValidCore(ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(value)), value.Length);

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Ascii.Transcoding.cs (4)

36fixed (byte* pSource = &MemoryMarshal.GetReference(source)) 37fixed (char* pDestination = &MemoryMarshal.GetReference(destination)) 71fixed (char* pSource = &MemoryMarshal.GetReference(source)) 72fixed (byte* pDestination = &MemoryMarshal.GetReference(destination))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\ASCIIEncoding.cs (10)

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Decoder.cs (5)

113fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 199fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 200fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 305fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 306fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\DecoderNLS.cs (7)

62fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 107fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 108fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 158fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 159fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 207MemoryMarshal.AsBytes(new ReadOnlySpan<int>(in _leftoverBytes)).Slice(0, _leftoverByteCount); 211bytes.CopyTo(MemoryMarshal.AsBytes(new Span<int>(ref _leftoverBytes)));

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Encoder.cs (5)

111fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 196fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 197fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 304fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 305fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\EncoderNLS.cs (5)

58fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 97fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 98fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 144fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 145fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Encoding.cs (7)

583fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 729fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 730fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 785fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 878fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 879fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 915fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes))

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

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\Latin1Encoding.cs (9)

84fixed (char* charsPtr = &MemoryMarshal.GetReference(chars)) 231fixed (char* charsPtr = &MemoryMarshal.GetReference(chars)) 232fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes)) 241fixed (char* charsPtr = &MemoryMarshal.GetReference(chars)) 242fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes)) 526fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes)) 527fixed (char* charsPtr = &MemoryMarshal.GetReference(chars)) 538fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes)) 539fixed (char* charsPtr = &MemoryMarshal.GetReference(chars))

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

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

304fixed (char* pValue = &MemoryMarshal.GetReference(utf16Data))

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

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

30fixed (byte* pUtf8Data = &MemoryMarshal.GetReference(utf8Data))

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

158fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 201fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 293fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\UTF32Encoding.cs (3)

166fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 209fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 301fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\UTF7Encoding.cs (3)

202fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 245fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 337fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars))

src\runtime\src\libraries\System.Private.CoreLib\src\System\Text\UTF8Encoding.cs (10)

System\Array.NativeAot.cs (3)

268ref byte arrayRef = ref MemoryMarshal.GetArrayDataReference(this); 386ref byte element = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(this), (nuint)flattenedIndex * ElementSize); 404ref byte element = ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(this), (nuint)flattenedIndex * ElementSize);

System\Reflection\EnumInfo.cs (1)

48return MemoryMarshal.Cast<TStorage, TResult>(Values).ToArray();

System\Runtime\InteropServices\PInvokeMarshal.cs (1)

550ReadOnlySpan<byte> span = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(pchBuffer);