MemoryMarshal

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

18int result = MkDir(ref MemoryMarshal.GetReference(converter.ConvertAndTerminateString(path)), mode);

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

40ref byte pathReference = ref MemoryMarshal.GetReference(converter.ConvertAndTerminateString(path)); 46int resultLength = ReadLink(ref pathReference, ref MemoryMarshal.GetReference(spanBuffer), spanBuffer.Length);

src\libraries\Common\src\Interop\Unix\System.Native\Interop.Rename.cs (2)

31ref MemoryMarshal.GetReference(converterOldPath.ConvertAndTerminateString(oldPath)), 32ref MemoryMarshal.GetReference(converterNewPath.ConvertAndTerminateString(newPath)));

src\libraries\Common\src\Interop\Unix\System.Native\Interop.Stat.Span.cs (2)

18int result = Stat(ref MemoryMarshal.GetReference(converter.ConvertAndTerminateString(path)), out output); 29int result = LStat(ref MemoryMarshal.GetReference(converter.ConvertAndTerminateString(path)), out output);

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

117ref byte srcRef = ref MemoryMarshal.GetReference(bytes); 118ref ushort destRef = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars)); 254ref ushort srcRef = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars)); 255ref byte destRef = ref MemoryMarshal.GetReference(bytes);

src\libraries\Common\src\System\Memory\FixedBufferExtensions.cs (1)

15fixed (char* c = &MemoryMarshal.GetReference(span))

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

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

src\libraries\Common\src\System\Text\ValueStringBuilder.cs (2)

64return ref MemoryMarshal.GetReference(_chars); 78return ref MemoryMarshal.GetReference(_chars);

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

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

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

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

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

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;

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

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

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

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

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

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

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 (5)

29fixed (T* srcBytes = &MemoryMarshal.GetReference(source)) 30fixed (byte* destBytes = &MemoryMarshal.GetReference(bytes)) 126ref sbyte decodingMap = ref MemoryMarshal.GetReference(decoder.DecodingMap); 326fixed (byte* bufferBytes = &MemoryMarshal.GetReference(buffer)) 337ref sbyte decodingMap = ref MemoryMarshal.GetReference(decoder.DecodingMap);

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

28fixed (byte* srcBytes = &MemoryMarshal.GetReference(source)) 29fixed (T* destBytes = &MemoryMarshal.GetReference(destination)) 82ref byte encodingMap = ref MemoryMarshal.GetReference(encoder.EncodingMap); 595fixed (byte* bufferBytes = &MemoryMarshal.GetReference(buffer)) 608ref byte encodingMap = ref MemoryMarshal.GetReference(encoder.EncodingMap);

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

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

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

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

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

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

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

322result = Unsafe.Add(ref MemoryMarshal.GetReference(source), source.Length - sizeof(byte)); 355result = MemoryMarshal.GetReference(source); 374MemoryMarshal.GetReference(destination) = value; 392MemoryMarshal.GetReference(destination) = value;

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

1202ref byte sourceRef = ref MemoryMarshal.GetReference(source); 1252ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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\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\libraries\System.Private.CoreLib\src\System\Convert.Base64.cs (3)

33ref char srcChars = ref MemoryMarshal.GetReference(utf16); 34ref byte destBytes = ref MemoryMarshal.GetReference(bytes); 45ref sbyte decodingMap = ref MemoryMarshal.GetReference(DecodingMap);

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

2368fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes)) 2457fixed (char* outChars = &MemoryMarshal.GetReference(chars)) 2458fixed (byte* inData = &MemoryMarshal.GetReference(bytes)) 2482OperationStatus status = Base64.EncodeToUtf8(bytes, MemoryMarshal.AsBytes(chars), out _, out int bytesWritten); 2488ref ushort dest = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars));

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

1186ref byte address = ref MemoryMarshal.GetReference(destination); 1215ref byte address = ref MemoryMarshal.GetReference(destination);

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

58decodedFields[i] = MemoryMarshal.Read<byte>(payload); 63decodedFields[i] = MemoryMarshal.Read<sbyte>(payload); 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\libraries\System.Private.CoreLib\src\System\Enum.cs (2)

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

src\libraries\System.Private.CoreLib\src\System\Enum.EnumInfo.cs (1)

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

src\libraries\System.Private.CoreLib\src\System\Environment.Variables.Windows.cs (2)

37uint length = Interop.Kernel32.GetEnvironmentVariable(variable, ref MemoryMarshal.GetReference(span), (uint)span.Length); 97ReadOnlySpan<char> variable = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(currentPtr);

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\libraries\System.Private.CoreLib\src\System\Globalization\CalendarData.Icu.cs (1)

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

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

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

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

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

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

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

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

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\libraries\System.Private.CoreLib\src\System\Globalization\Normalization.Icu.cs (1)

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

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

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

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\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\libraries\System.Private.CoreLib\src\System\Globalization\OrdinalCasing.Icu.cs (4)

296fixed (char* pSource = &MemoryMarshal.GetReference(source)) 297fixed (char* pValue = &MemoryMarshal.GetReference(value)) 360fixed (char* pSource = &MemoryMarshal.GetReference(source)) 361fixed (char* pValue = &MemoryMarshal.GetReference(value))

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

251fixed (char* pSource = &MemoryMarshal.GetReference(source)) 252fixed (char* pDestination = &MemoryMarshal.GetReference(destination))

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

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

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

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

320ref byte pos = ref MemoryMarshal.GetReference(value);

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

800ref byte sourceRef = ref MemoryMarshal.GetReference(source); 882ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

344ref byte sourceRef = ref MemoryMarshal.GetReference(source); 419ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

364ref byte sourceRef = ref MemoryMarshal.GetReference(source); 446ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

361ref byte sourceRef = ref MemoryMarshal.GetReference(source); 443ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

366ref byte sourceRef = ref MemoryMarshal.GetReference(source); 448ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

98Span<char> buffer = MemoryMarshal.CreateSpan(ref _fileNameBuffer._buffer[0], Interop.Sys.DirectoryEntry.NameBufferSize);

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

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

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

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

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

27fixed (byte* bufPtr = &MemoryMarshal.GetReference(buffer)) 78fixed (Interop.Sys.IOVector* pinnedVectors = &MemoryMarshal.GetReference(vectors)) 104fixed (byte* bufPtr = &MemoryMarshal.GetReference(buffer)) 192fixed (Interop.Sys.IOVector* pinnedVectors = &MemoryMarshal.GetReference(left))

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

310if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> array)) 732if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> array))

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

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

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\libraries\System.Private.CoreLib\src\System\IO\TextWriter.cs (2)

593MemoryMarshal.TryGetArray(buffer, out ArraySegment<char> array) ? 657MemoryMarshal.TryGetArray(buffer, out ArraySegment<char> array) ?

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

393SpanHelpers.Memmove(ref MemoryMarshal.GetReference(buffer), ref *(pointer + pos + _offset), (nuint)nInt); 405SpanHelpers.Memmove(ref MemoryMarshal.GetReference(buffer), ref *(_mem + pos), (nuint)nInt); 467MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> destinationArray) ? 672SpanHelpers.Memmove(ref *(pointer + pos + _offset), ref MemoryMarshal.GetReference(buffer), (nuint)buffer.Length); 684SpanHelpers.Memmove(ref *(_mem + pos), ref MemoryMarshal.GetReference(buffer), (nuint)buffer.Length); 733if (MemoryMarshal.TryGetArray(buffer, out ArraySegment<byte> sourceArray))

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

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

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

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 (4)

307refToReturn = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject)); 320refToReturn = ref MemoryMarshal.GetReference(memoryManagerSpan); 417void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index & ReadOnlyMemory<T>.RemoveFlagsBitMask); 424void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index);

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

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

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\libraries\System.Private.CoreLib\src\System\Net\WebUtility.cs (1)

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

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

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

395ref MemoryMarshal.GetReference(Log2DeBruijn), 578ref MemoryMarshal.GetReference(TrailingZeroCountDeBruijn), 875ref uint lookupTable = ref MemoryMarshal.GetArrayDataReference(s_crcTable); 883ref uint lookupTable = ref MemoryMarshal.GetArrayDataReference(s_crcTable); 894ref uint lookupTable = ref MemoryMarshal.GetArrayDataReference(s_crcTable);

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

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

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)); 676Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), this); 690Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), this); 797Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), this); 812Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), this);

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

311return Unsafe.ReadUnaligned<Vector2>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 659Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this); 673Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);

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

346return Unsafe.ReadUnaligned<Vector3>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 692Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this); 706Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);

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

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

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

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

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

229refToReturn = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject)); 242refToReturn = ref MemoryMarshal.GetReference(memoryManagerSpan); 332void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index & RemoveFlagsBitMask); 339void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index);

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

47_reference = ref MemoryMarshal.GetArrayDataReference(array); 81_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */); 399Buffer.Memmove(ref MemoryMarshal.GetArrayDataReference(destination), ref _reference, (uint)_length);

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

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

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

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

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

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

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

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

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

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

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

18/// A <see cref="ReadOnlySpan{T}"/> marshalled with this marshaller will match the semantics of <see cref="MemoryMarshal.GetReference{T}(ReadOnlySpan{T})"/>. 44if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 104if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 141public ref TUnmanagedElement GetPinnableReference() => ref MemoryMarshal.GetReference(_span); 167return ref MemoryMarshal.GetReference(managed);

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

18/// A <see cref="Span{T}"/> marshalled with this marshaller will match the semantics of <see cref="MemoryMarshal.GetReference{T}(Span{T})"/>. 38if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 132if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 168public ref TUnmanagedElement GetPinnableReference() => ref MemoryMarshal.GetReference(_span); 194return ref MemoryMarshal.GetReference(managed);

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\NFloat.cs (4)

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

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\libraries\System.Private.CoreLib\src\System\Runtime\Intrinsics\ISimdVector_2.cs (3)

180TSelf.StoreUnsafe(vector, ref MemoryMarshal.GetReference(destination)); 217return TSelf.LoadUnsafe(ref MemoryMarshal.GetReference(values)); 660TSelf.StoreUnsafe(vector, ref MemoryMarshal.GetReference(destination));

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

824Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector); 1022return Unsafe.ReadUnaligned<Vector128<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 3512Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);

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

663Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector); 861return Unsafe.ReadUnaligned<Vector256<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 3377Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);

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

589Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector); 778return Unsafe.ReadUnaligned<Vector512<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 3370Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);

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

607Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector); 819return Unsafe.ReadUnaligned<Vector64<T>>(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(values))); 3397Unsafe.WriteUnaligned(ref Unsafe.As<T, byte>(ref MemoryMarshal.GetReference(destination)), vector);

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

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

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\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\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 (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\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\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\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\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\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\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\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 (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\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\libraries\System.Private.CoreLib\src\System\SearchValues\ProbabilisticMap.cs (1)

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

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

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

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

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

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

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

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

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

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

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

49_reference = ref MemoryMarshal.GetArrayDataReference(array); 86_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */); 429Buffer.Memmove(ref MemoryMarshal.GetArrayDataReference(destination), ref _reference, (uint)_length);

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

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

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

456=> SpanHelpers.SequenceCompareTo(ref MemoryMarshal.GetReference(strA), strA.Length, ref MemoryMarshal.GetReference(strB), strB.Length); 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)); 812return Marvin.ComputeHash32OrdinalIgnoreCase(ref MemoryMarshal.GetReference(value), value.Length /* in chars, not bytes */, (uint)seed, (uint)(seed >> 32)); 866fixed (char* src = &MemoryMarshal.GetReference(span)) 977fixed (char* src = &MemoryMarshal.GetReference(span))

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\libraries\System.Private.CoreLib\src\System\String.Manipulation.cs (3)

2044ref char source = ref MemoryMarshal.GetReference(sourceSpan); 2379fixed (char* pTrimChars = &MemoryMarshal.GetReference(trimChars)) 2420fixed (char* pTrimChars = &MemoryMarshal.GetReference(trimChars))

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

41=> ChangeCase<ushort, ushort, ToUpperConversion>(MemoryMarshal.Cast<char, ushort>(source), MemoryMarshal.Cast<char, ushort>(destination), out charsWritten); 53=> ChangeCase<byte, ushort, ToUpperConversion>(source, MemoryMarshal.Cast<char, ushort>(destination), out charsWritten); 65=> ChangeCase<ushort, byte, ToUpperConversion>(MemoryMarshal.Cast<char, ushort>(source), destination, out bytesWritten); 91=> ChangeCase<ushort, ushort, ToLowerConversion>(MemoryMarshal.Cast<char, ushort>(source), MemoryMarshal.Cast<char, ushort>(destination), out charsWritten); 103=> ChangeCase<byte, ushort, ToLowerConversion>(source, MemoryMarshal.Cast<char, ushort>(destination), out charsWritten); 115=> ChangeCase<ushort, byte, ToLowerConversion>(MemoryMarshal.Cast<char, ushort>(source), destination, out bytesWritten); 135=> ChangeCase<ushort, ToLowerConversion>(MemoryMarshal.Cast<char, ushort>(value), out charsWritten); 155=> ChangeCase<ushort, ToUpperConversion>(MemoryMarshal.Cast<char, ushort>(value), out charsWritten); 162if (MemoryMarshal.AsBytes(source).Overlaps(MemoryMarshal.AsBytes(destination))) 181fixed (TFrom* pSource = &MemoryMarshal.GetReference(source)) 182fixed (TTo* pDestination = &MemoryMarshal.GetReference(destination)) 196fixed (T* pBuffer = &MemoryMarshal.GetReference(buffer))

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\libraries\System.Private.CoreLib\src\System\Text\Ascii.Equality.cs (12)

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\libraries\System.Private.CoreLib\src\System\Text\ASCIIEncoding.cs (10)

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

112fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 198fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 199fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 304fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 305fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars))

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

61fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 106fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 107fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 157fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 158fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 206MemoryMarshal.AsBytes(new ReadOnlySpan<int>(in _leftoverBytes)).Slice(0, _leftoverByteCount); 210bytes.CopyTo(MemoryMarshal.AsBytes(new Span<int>(ref _leftoverBytes)));

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

110fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 195fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 196fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes)) 303fixed (char* charsPtr = &MemoryMarshal.GetNonNullPinnableReference(chars)) 304fixed (byte* bytesPtr = &MemoryMarshal.GetNonNullPinnableReference(bytes))

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

57fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 96fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 97fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes)) 143fixed (char* pChars = &MemoryMarshal.GetArrayDataReference(chars)) 144fixed (byte* pBytes = &MemoryMarshal.GetArrayDataReference(bytes))

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\libraries\System.Private.CoreLib\src\System\Text\Encoding.Internal.cs (18)

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

83fixed (char* charsPtr = &MemoryMarshal.GetReference(chars)) 230fixed (char* charsPtr = &MemoryMarshal.GetReference(chars)) 231fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes)) 240fixed (char* charsPtr = &MemoryMarshal.GetReference(chars)) 241fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes)) 525fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes)) 526fixed (char* charsPtr = &MemoryMarshal.GetReference(chars)) 537fixed (byte* bytesPtr = &MemoryMarshal.GetReference(bytes)) 538fixed (char* charsPtr = &MemoryMarshal.GetReference(chars))

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

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

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

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

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\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\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\libraries\System.Private.CoreLib\src\System\Text\UTF8Encoding.cs (10)

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

847ref byte sourceRef = ref MemoryMarshal.GetReference(source); 904ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

318ref byte sourceRef = ref MemoryMarshal.GetReference(source); 368ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

339ref byte sourceRef = ref MemoryMarshal.GetReference(source); 396ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

338ref byte sourceRef = ref MemoryMarshal.GetReference(source); 395ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

342ref byte sourceRef = ref MemoryMarshal.GetReference(source); 399ref byte sourceRef = ref MemoryMarshal.GetReference(source);

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

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\Reflection\AssemblyName.CoreCLR.cs (1)

149AssemblyNameParser.AssemblyNameParts parts = AssemblyNameParser.Parse(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(pAssemblyName));

src\System\Reflection\MdImport.cs (5)

264: Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(safeArrayUserDefinedSubTypeRaw)); 267: Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(marshalTypeRaw)); 270: Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(marshalCookieRaw)); 601importName = Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(importNameRaw)); 602importDll = Text.Encoding.UTF8.GetString(MemoryMarshal.CreateReadOnlySpanFromNullTerminated(importDllRaw));

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

133ReadOnlySpan<char> typeName = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(pTypeName);

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

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

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

51ref byte dst = ref MemoryMarshal.GetArrayDataReference(array);

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

183object? threadStaticObjectNonCollectible = Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(t_ThreadStatics->NonCollectibleTlsArrayData), indexOffset - ThreadLocalData.NUMBER_OF_TLSOFFSETS_NOT_USED_IN_NONCOLLECTIBLE_ARRAY);

src\System\StubHelpers.cs (3)

111SpanHelpers.Memmove(ref *pbNativeBuffer, ref MemoryMarshal.GetArrayDataReference(bytes), (nuint)nb); 368SpanHelpers.Memmove(ref *pNative, ref MemoryMarshal.GetArrayDataReference(bytes), (nuint)nbytesused); 417SpanHelpers.Memmove(ref *(byte*)bstr, ref MemoryMarshal.GetArrayDataReference(bytes), length);

src\System\ValueType.cs (2)

118hashCode.AddBytes(MemoryMarshal.CreateReadOnlySpan(ref rawData, (int)size)); 139hashCode.AddBytes(MemoryMarshal.CreateReadOnlySpan(ref Unsafe.AddByteOffset(ref rawData, fieldOffset), (int)fieldSize));