Unsafe

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

119ref ushort destRef = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars)); 140uint i32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref srcRef, pos)); 270ref ushort srcRef = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars)); 334Unsafe.WriteUnaligned(ref Unsafe.Add(ref destRef, offset / 2), output.AsUInt64().ToScalar());

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

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

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

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

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

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

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

53Memmove(ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(dst), uDstOffset), ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(src), uSrcOffset), uCount); 85return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index); 96Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index) = value; 158ref Unsafe.As<T, byte>(ref destination), 159ref Unsafe.As<T, byte>(ref source), 166ref Unsafe.As<T, byte>(ref destination), 167ref Unsafe.As<T, byte>(ref source), 198if (Unsafe.AreSame(ref source, ref destination)) 202if ((nuint)(nint)Unsafe.ByteOffset(ref source, ref destination) >= byteCount) 210destination = ref Unsafe.AddByteOffset(ref destination, BulkMoveWithWriteBarrierChunk); 211source = ref Unsafe.AddByteOffset(ref source, BulkMoveWithWriteBarrierChunk); 221BulkMoveWithWriteBarrierInternal(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src\libraries\System.Private.CoreLib\src\System\Buffers\Text\Utf8Parser\Utf8Parser.Integer.Signed.cs (8)

58Unsafe.SkipInit(out value); // will be populated by TryParseByteX 59return TryParseByteX(source, out Unsafe.As<sbyte, byte>(ref value), out bytesConsumed); 110Unsafe.SkipInit(out value); // will be populated by TryParseUInt16X 111return TryParseUInt16X(source, out Unsafe.As<short, ushort>(ref value), out bytesConsumed); 162Unsafe.SkipInit(out value); // will be populated by TryParseUInt32X 163return TryParseUInt32X(source, out Unsafe.As<int, uint>(ref value), out bytesConsumed); 214Unsafe.SkipInit(out value); // will be populated by TryParseUInt64X 215return TryParseUInt64X(source, out Unsafe.As<long, ulong>(ref value), out bytesConsumed);

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

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

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

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

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

1239sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(char)); 1242result = Unsafe.ReadUnaligned<char>(ref sourceRef); 1290result = Unsafe.ReadUnaligned<char>(ref sourceRef);

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

170ref byte value = ref Unsafe.As<bool, byte>(ref MemoryMarshal.GetArrayDataReference<bool>(values)); 179Unsafe.WriteUnaligned(ref Unsafe.Add(ref arrayRef, sizeof(ulong) * (i / 64u)), ~result); 190Unsafe.WriteUnaligned(ref Unsafe.Add(ref arrayRef, sizeof(uint) * (i / 32u)), ~result); 205Unsafe.WriteUnaligned( 206ref Unsafe.Add(ref arrayRef, sizeof(uint) * (i / 32u)),

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\EventSource.cs (2)

2833if (Unsafe.IsNullRef(ref eventMeta)) return false; 3342if (!Unsafe.IsNullRef(ref startEventMetadata))

src\libraries\System.Private.CoreLib\src\System\Diagnostics\Tracing\NativeRuntimeEventSource.cs (1)

55if (Unsafe.IsNullRef(ref metadata))

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

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

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

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

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

766result.Append(Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(s)); 771Encoding.UTF8.GetBytes(s, Unsafe.BitCast<Span<TChar>, Span<byte>>(result.AppendSpan(Encoding.UTF8.GetByteCount(s)))); 780fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<char>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture) : 781fraction.TryFormat(Unsafe.BitCast<Span<TChar>, Span<byte>>(chars), out charCount, fractionFormat, CultureInfo.InvariantCulture); 1115bool success = Unsafe.AreSame(ref MemoryMarshal.GetReference(destination), ref MemoryMarshal.GetReference(vlb.AsSpan()));

src\libraries\System.Private.CoreLib\src\System\Globalization\DateTimeFormatInfo.cs (10)

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

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

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

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

33charA = ref Unsafe.Add(ref charA, 1); 34charB = ref Unsafe.Add(ref charB, 1); 96vec1 = TVector.LoadUnsafe(ref Unsafe.As<char, ushort>(ref charA), i); 97vec2 = TVector.LoadUnsafe(ref Unsafe.As<char, ushort>(ref charB), i); 123vec1 = TVector.LoadUnsafe(ref Unsafe.As<char, ushort>(ref charA), i); 124vec2 = TVector.LoadUnsafe(ref Unsafe.As<char, ushort>(ref charB), i); 155ref Unsafe.Add(ref charA, i), (int)(lengthU - i), 156ref Unsafe.Add(ref charB, i), (int)(lengthU - i)) == 0; 187valueAu64 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charA, byteOffset))); 188valueBu64 = Unsafe.ReadUnaligned<ulong>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charB, byteOffset))); 222valueAu32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charA, byteOffset))); 223valueBu32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.As<char, byte>(ref Unsafe.AddByteOffset(ref charB, byteOffset))); 250valueAu32 = Unsafe.AddByteOffset(ref charA, byteOffset); 251valueBu32 = Unsafe.AddByteOffset(ref charB, byteOffset); 294return CompareStringIgnoreCase(ref Unsafe.AddByteOffset(ref charA, byteOffset), length, ref Unsafe.AddByteOffset(ref charB, byteOffset), length) == 0; 377valueCharU = Unsafe.Add(ref valueRef, valueTailLength); 400? PackedSpanHelpers.IndexOfAnyIgnoreCase(ref Unsafe.Add(ref searchSpace, offset), valueCharL, searchSpaceMinusValueTailLength) 401: SpanHelpers.IndexOfAnyChar(ref Unsafe.Add(ref searchSpace, offset), valueCharU, valueCharL, searchSpaceMinusValueTailLength) : 402SpanHelpers.IndexOfChar(ref Unsafe.Add(ref searchSpace, offset), valueChar, searchSpaceMinusValueTailLength); 418ref Unsafe.Add(ref searchSpace, (nuint)(offset + 1)), 419ref Unsafe.Add(ref valueRef, 1), valueTailLength)) 445char tmp = Unsafe.Add(ref valueRef, ch1ch2Distance - 1); 507if (EqualsIgnoreCase(ref Unsafe.Add(ref searchSpace, offset + charPos), ref valueRef, value.Length)) 573if (EqualsIgnoreCase(ref Unsafe.Add(ref searchSpace, offset + charPos), ref valueRef, value.Length))

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

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

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

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

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

248return Unsafe.As<GuidResult, Guid>(ref Unsafe.AsRef(in this)); 324Unsafe.AsRef(in result._a) = (int)(unix_ts_ms >> 16); 325Unsafe.AsRef(in result._b) = (short)(unix_ts_ms); 327Unsafe.AsRef(in result._c) = (short)((result._c & ~VersionMask) | Version7Value); 328Unsafe.AsRef(in result._d) = (byte)((result._d & ~Variant10xxMask) | Variant10xxValue); 795Unsafe.Add(ref result._d, i) = (byte)byteVal; 889ReadOnlySpan<char> charSpan = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<char>>(str); 918return Unsafe.BitCast<ReadOnlySpan<char>, ReadOnlySpan<TChar>>(new ReadOnlySpan<char>(chArr, 0, newLength)); 924ReadOnlySpan<byte> srcUtf8Span = Unsafe.BitCast<ReadOnlySpan<TChar>, ReadOnlySpan<byte>>(str); 977return Unsafe.BitCast<ReadOnlySpan<byte>, ReadOnlySpan<TChar>>(destUtf8Span.Slice(0, newLength)); 1066ref int r = ref Unsafe.AsRef(in _a); 1067return r ^ Unsafe.Add(ref r, 1) ^ Unsafe.Add(ref r, 2) ^ Unsafe.Add(ref r, 3); 1081return Unsafe.BitCast<Guid, Vector128<byte>>(left) == Unsafe.BitCast<Guid, Vector128<byte>>(right); 1084ref int rA = ref Unsafe.AsRef(in left._a); 1085ref int rB = ref Unsafe.AsRef(in right._a); 1090&& Unsafe.Add(ref rA, 1) == Unsafe.Add(ref rB, 1) 1091&& Unsafe.Add(ref rA, 2) == Unsafe.Add(ref rB, 2) 1092&& Unsafe.Add(ref rA, 3) == Unsafe.Add(ref rB, 3); 1517Vector128<byte> srcVec = Unsafe.BitCast<Guid, Vector128<byte>>(value);

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

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

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

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

800sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - Size); 803result = Unsafe.ReadUnaligned<Int128>(ref sourceRef); 819result |= Unsafe.Add(ref sourceRef, i); 883result = Unsafe.ReadUnaligned<Int128>(ref sourceRef); 901result |= Unsafe.Add(ref sourceRef, i);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

180return Unsafe.Add(ref Unsafe.AsRef(in AsROImpl()).X, row); 222Unsafe.Add(ref AsImpl().X, row) = value; 281return Unsafe.Add(ref Unsafe.AsRef(in M11), (row * ColumnCount) + column); 323Unsafe.Add(ref M11, (row * ColumnCount) + column) = value; 416Unsafe.SkipInit(out Matrix3x2 result); 530Unsafe.SkipInit(out result);

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

20internal ref Impl AsImpl() => ref Unsafe.As<Matrix3x2, Impl>(ref this); 24internal readonly ref readonly Impl AsROImpl() => ref Unsafe.As<Matrix3x2, Impl>(ref Unsafe.AsRef(in this)); 30public ref Matrix3x2 AsM3x2() => ref Unsafe.As<Impl, Matrix3x2>(ref this);

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

259return Unsafe.Add(ref Unsafe.AsRef(in impl.X), row); 309Unsafe.Add(ref Unsafe.AsRef(in impl.X), row) = value; 375return Unsafe.Add(ref Unsafe.AsRef(in M11), (row * ColumnCount) + column); 425Unsafe.Add(ref Unsafe.AsRef(in M11), (row * ColumnCount) + column) = value; 535Unsafe.SkipInit(out Matrix4x4 result); 976Unsafe.SkipInit(out result);

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

23internal ref Impl AsImpl() => ref Unsafe.As<Matrix4x4, Impl>(ref this); 27internal readonly ref readonly Impl AsROImpl() => ref Unsafe.As<Matrix4x4, Impl>(ref Unsafe.AsRef(in this)); 33public ref Matrix4x4 AsM4x4() => ref Unsafe.As<Impl, Matrix4x4>(ref this); 1132scale = Unsafe.ReadUnaligned<Vector3>(scales);

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

14public static Vector4 AsVector4(this Plane value) => Unsafe.BitCast<Plane, Vector4>(value);

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

14public static Vector4 AsVector4(this Quaternion value) => Unsafe.BitCast<Quaternion, Vector4>(value);

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

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

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

411return Unsafe.ReadUnaligned<Vector2>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 704ref readonly byte address = ref Unsafe.As<float, byte>(ref Unsafe.AsRef(in source)); 705return Unsafe.ReadUnaligned<Vector2>(in address); 714ref readonly byte address = ref Unsafe.As<float, byte>(ref Unsafe.Add(ref Unsafe.AsRef(in source), (nint)elementOffset)); 715return Unsafe.ReadUnaligned<Vector2>(in address); 974Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this); 1002Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this); 1016Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this); 1030Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);

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

84ref byte address = ref Unsafe.As<float, byte>(ref destination); 85Unsafe.WriteUnaligned(ref address, source); 96destination = ref Unsafe.Add(ref destination, (nint)elementOffset); 97Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref destination), source);

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

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

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

79ref byte address = ref Unsafe.As<float, byte>(ref destination); 80Unsafe.WriteUnaligned(ref address, source); 91destination = ref Unsafe.Add(ref destination, (nint)elementOffset); 92Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref destination), source);

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

15public static Plane AsPlane(this Vector4 value) => Unsafe.BitCast<Vector4, Plane>(value); 20public static Quaternion AsQuaternion(this Vector4 value) => Unsafe.BitCast<Vector4, Quaternion>(value);

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

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

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

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

83_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */); 119_reference = ref Unsafe.AsRef(in reference); 150return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */); 227return new ReadOnlySpan<T>(ref Unsafe.As<TDerived, T>(ref items._reference), items.Length); 292ref T ret = ref Unsafe.NullRef<T>(); 348Unsafe.AreSame(ref left._reference, ref right._reference); 358return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length)); 376return new ReadOnlySpan<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start); 399return new ReadOnlySpan<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), length);

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

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

src\libraries\System.Private.CoreLib\src\System\Reflection\FieldAccessor.cs (30)

131return Volatile.Read(ref Unsafe.As<byte, object>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset))); 142ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)); 148(void*)Unsafe.As<byte, IntPtr>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 152return Volatile.Read(ref Unsafe.As<IntPtr, object>(ref *(IntPtr*)_addressOrOffset)); 159return RuntimeHelpers.Box(_methodTable, ref Unsafe.AsRef<byte>(_addressOrOffset.ToPointer())); 165ref Unsafe.As<IntPtr, object>(ref *(IntPtr*)_addressOrOffset).GetRawData()); 168return Pointer.Box((void*)Unsafe.As<byte, IntPtr>( 169ref Unsafe.AsRef<byte>(_addressOrOffset.ToPointer())), _fieldInfo.FieldType); 223ref Unsafe.As<byte, object?>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 231ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset), 239ref Unsafe.As<byte, short>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 240Unsafe.As<byte, short>(ref value!.GetRawData())); 247ref Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 248Unsafe.As<byte, int>(ref value!.GetRawData())); 255ref Unsafe.As<byte, long>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 256Unsafe.As<byte, long>(ref value!.GetRawData())); 261Volatile.Write(ref Unsafe.As<IntPtr, object?>(ref *(IntPtr*)_addressOrOffset), value); 267ref Unsafe.AsRef<byte>(_addressOrOffset.ToPointer()), 274ref Unsafe.AsRef<short>(_addressOrOffset.ToPointer()), 275Unsafe.As<byte, short>(ref value!.GetRawData())); 281ref Unsafe.AsRef<int>(_addressOrOffset.ToPointer()), 282Unsafe.As<byte, int>(ref value!.GetRawData())); 288ref Unsafe.AsRef<long>(_addressOrOffset.ToPointer()), 289Unsafe.As<byte, long>(ref value!.GetRawData()));

src\libraries\System.Private.CoreLib\src\System\Reflection\InvokeUtils.cs (55)

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

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

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

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

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

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

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

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

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

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

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

634value = Unsafe.As<TValue>(secondary); 685key = Unsafe.As<TKey>(oKey); 686value = Unsafe.As<TValue>(oValue); 714value = Unsafe.As<TValue>(valueObject);

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

63Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, 85Unsafe.As<IValueTaskSource>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, 105Unsafe.As<IValueTaskSource>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token, 168Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, 190Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ValueTaskAwaiter.s_invokeActionDelegate, continuation, _value._token, 210Unsafe.As<IValueTaskSource<TResult>>(obj).OnCompleted(ThreadPool.s_invokeAsyncStateMachineBox, box, _value._token,

src\libraries\System.Private.CoreLib\src\System\Runtime\CompilerServices\GenericCache.cs (5)

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

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

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

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

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

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

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

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

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\ComWrappers.cs (4)

135return Unsafe.As<T>(comInstance->Holder!.WrappedObject); 229return Unsafe.As<ManagedObjectWrapperHolder>(GCHandle.FromIntPtr(handle).Target); 448Interlocked.Or(ref Unsafe.As<CreateComInterfaceFlagsEx, int>(ref Flags), setMask); 454Interlocked.And(ref Unsafe.As<CreateComInterfaceFlagsEx, int>(ref Flags), resetMask);

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

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

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

52return Unsafe.As<T>(GCHandle.InternalGet(handle));

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

36return (T*)Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(array)); 59return (char*)Unsafe.AsPointer(ref str.GetRawStringData());

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\NFloat.cs (16)

697Unsafe.SkipInit(out result); 698return NativeType.TryParse(s, out Unsafe.As<NFloat, NativeType>(ref result)); 707Unsafe.SkipInit(out result); 708return NativeType.TryParse(s, out Unsafe.As<NFloat, NativeType>(ref result)); 717Unsafe.SkipInit(out result); 718return NativeType.TryParse(utf8Text, out Unsafe.As<NFloat, NativeType>(ref result)); 734Unsafe.SkipInit(out result); 735return NativeType.TryParse(s, style, provider, out Unsafe.As<NFloat, NativeType>(ref result)); 751Unsafe.SkipInit(out result); 752return NativeType.TryParse(s, style, provider, out Unsafe.As<NFloat, NativeType>(ref result)); 1052Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 1076Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 1100Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand); 1124Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand); 1922Unsafe.SkipInit(out result); 1923return NativeType.TryParse(utf8Text, style, provider, out Unsafe.As<NFloat, NativeType>(ref result));

src\libraries\System.Private.CoreLib\src\System\Runtime\InteropServices\PinnedGCHandle.T.cs (2)

54return Unsafe.As<T>(GCHandle.InternalGet(handle)); 93return Unsafe.AsPointer(ref target.GetRawData());

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

14private static readonly unsafe IntPtr s_globalHostServices = (IntPtr)Unsafe.AsPointer(in HostServices.Vftbl); 19IReferenceTrackerManager.SetReferenceTrackerHost(trackerManager, (IntPtr)Unsafe.AsPointer(in s_globalHostServices));

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

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

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

75ReferenceTrackerNativeObjectWrapper? nativeObjectWrapper = Unsafe.As<ReferenceTrackerNativeObjectWrapper?>(weakNativeObjectWrapperHandle.Target);

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

56T? obj = Unsafe.As<T?>(GCHandle.InternalGet(handle));

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

275Unsafe.SkipInit(out TSelf result);

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

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

56public static Plane AsPlane(this Vector128<float> value) => Unsafe.BitCast<Vector128<float>, Plane>(value); 62public static Quaternion AsQuaternion(this Vector128<float> value) => Unsafe.BitCast<Vector128<float>, Quaternion>(value); 68public static Vector128<float> AsVector128(this Plane value) => Unsafe.BitCast<Plane, Vector128<float>>(value); 74public static Vector128<float> AsVector128(this Quaternion value) => Unsafe.BitCast<Quaternion, Vector128<float>>(value); 92public static Vector128<float> AsVector128(this Vector4 value) => Unsafe.BitCast<Vector4, Vector128<float>>(value); 106ref byte address = ref Unsafe.As<Vector<T>, byte>(ref value); 107return Unsafe.ReadUnaligned<Vector128<T>>(ref address); 119Unsafe.SkipInit(out Vector128<float> result); 120Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<float>, byte>(ref result), value); 133Unsafe.SkipInit(out Vector128<float> result); 134Unsafe.WriteUnaligned(ref Unsafe.As<Vector128<float>, byte>(ref result), value); 145ref byte address = ref Unsafe.As<Vector128<float>, byte>(ref value); 146return Unsafe.ReadUnaligned<Vector2>(ref address); 156ref byte address = ref Unsafe.As<Vector128<float>, byte>(ref value); 157return Unsafe.ReadUnaligned<Vector3>(ref address); 164public static Vector4 AsVector4(this Vector128<float> value) => Unsafe.BitCast<Vector128<float>, Vector4>(value); 179Unsafe.WriteUnaligned(ref Unsafe.As<Vector<T>, byte>(ref result), value);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

36SpanHelpers.NonPackedIndexOfValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length); 40SpanHelpers.NonPackedIndexOfValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length); 44SpanHelpers.LastIndexOfValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length); 48SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length);

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

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

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

36SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length); 40SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length); 44SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length); 48SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length);

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

36SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length); 40SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length); 44SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length); 48SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length);

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

39SpanHelpers.IndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length); 43SpanHelpers.IndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length); 47SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length); 51SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length);

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

40SpanHelpers.IndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length); 44SpanHelpers.IndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length); 48SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length); 52SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length);

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

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

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

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

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

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

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

88return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(hashEntries), (nuint)offset) == value; 98ref Unsafe.As<ProbabilisticMap, uint>(ref Map), 234ref char searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength); 244while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd)) 249return (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref cur) / sizeof(char)); 252cur = ref Unsafe.Add(ref cur, 1); 257while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd)) 262return (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref cur) / sizeof(char)); 265cur = ref Unsafe.Add(ref cur, 1); 286char c = Unsafe.Add(ref searchSpace, searchSpaceLength); 297char c = Unsafe.Add(ref searchSpace, searchSpaceLength);

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

60ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), 70ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), 109ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), 159ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), 169ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), 198ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)),

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

45ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(span)), 55ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(span)),

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

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

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

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

100ref Unsafe.As<char, short>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i)), 102ref Unsafe.AsRef(in _startingAsciiChars)); 123char c = TCaseSensitivity.TransformInput(Unsafe.Add(ref MemoryMarshal.GetReference(span), i)); 128ref AhoCorasickNode node = ref Unsafe.Add(ref nodes, (uint)nodeIndex); 136int matchLength = Unsafe.Add(ref nodes, (uint)nodeIndex).MatchLength; 209ref Unsafe.As<char, short>(ref Unsafe.Add(ref MemoryMarshal.GetReference(span), i)), 211ref Unsafe.AsRef(in _startingAsciiChars)); 242c = Unsafe.Add(ref MemoryMarshal.GetReference(span), i); 247char.IsLowSurrogate(lowSurrogate = Unsafe.Add(ref MemoryMarshal.GetReference(span), i + 1))) 277ref AhoCorasickNode node = ref Unsafe.Add(ref nodes, (uint)nodeIndex); 285int matchLength = Unsafe.Add(ref nodes, (uint)nodeIndex).MatchLength;

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

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

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

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

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

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

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

88_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */); 155return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */); 285ref T ret = ref Unsafe.NullRef<T>(); 298SpanHelpers.ClearWithReferences(ref Unsafe.As<T, IntPtr>(ref _reference), (uint)_length * (nuint)(sizeof(T) / sizeof(nuint))); 302SpanHelpers.ClearWithoutReferences(ref Unsafe.As<T, byte>(ref _reference), (uint)_length * (nuint)sizeof(T)); 366Unsafe.AreSame(ref left._reference, ref right._reference); 382return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length)); 400return new Span<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start); 428return new Span<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), length);

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

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

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

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

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

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

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

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

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

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

112source: ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(value), startIndex)); 386slice = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, (nint)(uint)startIndex /* force zero-extension */), count); 427destination: ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), destinationIndex), 428source: ref Unsafe.Add(ref _firstChar, sourceIndex), 497source: ref Unsafe.Add(ref _firstChar, startIndex), 528internal ref byte GetRawStringDataAsUInt8() => ref Unsafe.As<char, byte>(ref _firstChar); 529internal ref ushort GetRawStringDataAsUInt16() => ref Unsafe.As<char, ushort>(ref _firstChar); 573Unsafe.Add(ref result._firstChar, 1) = c2; 735return Unsafe.Add(ref _firstChar, (nint)(uint)index /* force zero-extension */);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

32Unsafe.As<ThreadLocalNode>(threadLocalCountObject).Increment(); 39Unsafe.As<ThreadLocalNode>(threadLocalCountObject).Decrement(); 46Unsafe.As<ThreadLocalNode>(threadLocalCountObject).Add(count);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

165ref byte offsetDataRef = ref Unsafe.Add(ref arrayDataRef, flattenedIndex * pMethodTable->ComponentSize); 173ref object elementRef = ref Unsafe.As<byte, object>(ref arrayDataRef); 174ref object offsetElementRef = ref Unsafe.Add(ref elementRef, (nuint)flattenedIndex); 207ref byte offsetDataRef = ref Unsafe.Add(ref arrayDataRef, flattenedIndex * pMethodTable->ComponentSize); 211SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, nint>(ref offsetDataRef), elementSize / (nuint)sizeof(IntPtr)); 221Unsafe.Add(ref Unsafe.As<byte, object?>(ref arrayDataRef), (nuint)flattenedIndex) = null; 230Unsafe.Add(ref Unsafe.As<byte, object?>(ref arrayDataRef), (nuint)flattenedIndex) = value; 236ref byte offsetDataRef = ref Unsafe.Add(ref arrayDataRef, flattenedIndex * pMethodTable->ComponentSize); 288public int Length => checked((int)Unsafe.As<RawArrayData>(this).Length); 291internal nuint NativeLength => Unsafe.As<RawArrayData>(this).Length; 344arrayRef = ref Unsafe.Add(ref arrayRef, elementSize); 404T[] @this = Unsafe.As<T[]>(this); 414T[] @this = Unsafe.As<T[]>(this); 422T[] @this = Unsafe.As<T[]>(this); 430T[] @this = Unsafe.As<T[]>(this); 443T[] @this = Unsafe.As<T[]>(this); 462T[] @this = Unsafe.As<T[]>(this); 483T[] @this = Unsafe.As<T[]>(this);

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

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

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

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

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

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

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

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

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

57MulticastDelegate d = Unsafe.As<MulticastDelegate>(obj); 170MulticastDelegate result = Unsafe.As<MulticastDelegate>(RuntimeTypeHandle.InternalAllocNoChecks(RuntimeHelpers.GetMethodTable(this)));

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

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

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

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

src\System\Runtime\CompilerServices\AsyncHelpers.CoreCLR.cs (4)

265result = Unsafe.As<byte, T>(ref continuation.GCData![0]!.GetRawData()); 269result = Unsafe.As<object, T>(ref continuation.GCData![0]!); 274result = Unsafe.As<byte, T>(ref continuation.Data![0]); 552finalContinuation.Data = new byte[Unsafe.SizeOf<T>()];

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

430ref object? element = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index); 447ref object? element = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index); 539ref byte srcValue = ref Unsafe.Add(ref nullableData, srcMT->NullableValueAddrOffset); 552_ = Unsafe.ReadUnaligned<byte>(ref unboxedData); 639SpanHelpers.ClearWithReferences(ref Unsafe.As<byte, IntPtr>(ref destPtr), typeMT->GetNumInstanceFieldBytesIfContainsGCPointers() / (nuint)sizeof(IntPtr)); 650Unsafe.As<byte, bool>(ref destPtr) = true; 651ref byte dst = ref Unsafe.Add(ref destPtr, typeMT->NullableValueAddrOffset);

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

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

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

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

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

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

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

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

src\System\RuntimeHandles.cs (3)

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

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

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

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

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

src\System\StubHelpers.cs (3)

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

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

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

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

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

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

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

src\System\ValueType.cs (8)

126hashCode.Add(Unsafe.As<byte, object>(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode()); 130hashCode.Add(Unsafe.As<byte, double>(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode()); 134hashCode.Add(Unsafe.As<byte, float>(ref Unsafe.AddByteOffset(ref rawData, fieldOffset)).GetHashCode()); 139hashCode.AddBytes(MemoryMarshal.CreateReadOnlySpan(ref Unsafe.AddByteOffset(ref rawData, fieldOffset), (int)fieldSize)); 145hashCode.Add(RuntimeHelpers.Box(fieldMT, ref Unsafe.AddByteOffset(ref rawData, fieldOffset))?.GetHashCode() ?? 0);