Unsafe

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

117ref ushort destRef = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars)); 138uint i32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref srcRef, pos)); 255ref ushort srcRef = ref Unsafe.As<char, ushort>(ref MemoryMarshal.GetReference(chars)); 307Unsafe.WriteUnaligned(ref Unsafe.Add(ref destRef, offset / 2), output.AsUInt64().ToScalar());

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

53DigitsPtr = (byte*)Unsafe.AsPointer(ref MemoryMarshal.GetReference(digits)); // Safe since memory must be fixed

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

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

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

52Memmove(ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(dst), uDstOffset), ref Unsafe.AddByteOffset(ref MemoryMarshal.GetArrayDataReference(src), uSrcOffset), uCount); 84return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index); 95Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), index) = value; 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), 197if (Unsafe.AreSame(ref source, ref destination)) 201if ((nuint)(nint)Unsafe.ByteOffset(ref source, ref destination) >= byteCount) 208destination = ref Unsafe.AddByteOffset(ref destination, BulkMoveWithWriteBarrierChunk); 209source = ref Unsafe.AddByteOffset(ref source, BulkMoveWithWriteBarrierChunk); 219__BulkMoveWithWriteBarrier(ref Unsafe.AddByteOffset(ref destination, byteCount), ref Unsafe.AddByteOffset(ref source, byteCount), BulkMoveWithWriteBarrierChunk);

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

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

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

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

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

14int vectorElements = Unsafe.SizeOf<TVector>(); 28int vectorElements = Unsafe.SizeOf<TVector>();

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

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

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

28uint index = Unsafe.Add(ref MemoryMarshal.GetReference(log2ToPow10), BitOperations.Log2(value)); 56ulong powerOf10 = Unsafe.Add(ref MemoryMarshal.GetReference(powersOf10), index); 61return (int)(index - Unsafe.As<bool, byte>(ref lessThan)); // while arbitrary bools may be non-0/1, comparison operators are expected to return 0/1 106long tableValue = Unsafe.Add(ref MemoryMarshal.GetReference(table), uint.Log2(value));

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

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

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

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

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

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

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

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

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

1206sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(char)); 1209result = Unsafe.ReadUnaligned<char>(ref sourceRef); 1257result = Unsafe.ReadUnaligned<char>(ref sourceRef); 1287Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value); 1305Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);

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

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

233if (!Unsafe.IsNullRef(ref value)) 260if (!Unsafe.IsNullRef(ref value) && EqualityComparer<TValue>.Default.Equals(value, keyValuePair.Value)) 271if (!Unsafe.IsNullRef(ref value) && EqualityComparer<TValue>.Default.Equals(value, keyValuePair.Value)) 298!Unsafe.IsNullRef(ref FindValue(key)); 404ref Entry entry = ref Unsafe.NullRef<Entry>(); 484value = ref Unsafe.NullRef<TValue>(); 764Debug.Assert(!Unsafe.IsNullRef(ref value), "the lookup result cannot be a null ref here"); 1020if (!Unsafe.IsNullRef(ref valRef)) 1226if (!Unsafe.IsNullRef(ref value))

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

1103ref int bucket = ref Unsafe.NullRef<int>();

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

68ref Unsafe.As<char, byte>(ref obj.GetRawStringData()),

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

1150Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 1168Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 1196Unsafe.WriteUnaligned(ref address, hi32); 1197Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref address, sizeof(uint)), lo64); 1225Unsafe.WriteUnaligned(ref address, lo64); 1226Unsafe.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; 94=> new InvocationListEnumerator<TDelegate>(Unsafe.As<MulticastDelegate>(d)); 126if ((_current = Unsafe.As<TDelegate>(_delegate?.TryGetAt(index))) == null)

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

737Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 761Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 785Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand); 809Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);

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

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

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

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

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

1115bool success = Unsafe.AreSame(ref MemoryMarshal.GetReference(destination), ref MemoryMarshal.GetReference(vlb.AsSpan()));

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

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

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

235return Unsafe.As<GuidResult, Guid>(ref Unsafe.AsRef(in this)); 717Unsafe.Add(ref result._d, i) = (byte)byteVal; 924ref int r = ref Unsafe.AsRef(in _a); 925return r ^ Unsafe.Add(ref r, 1) ^ Unsafe.Add(ref r, 2) ^ Unsafe.Add(ref r, 3); 939return Vector128.LoadUnsafe(ref Unsafe.As<Guid, byte>(ref Unsafe.AsRef(in left))) == Vector128.LoadUnsafe(ref Unsafe.As<Guid, byte>(ref Unsafe.AsRef(in right))); 942ref int rA = ref Unsafe.AsRef(in left._a); 943ref int rB = ref Unsafe.AsRef(in right._a); 948&& Unsafe.Add(ref rA, 1) == Unsafe.Add(ref rB, 1) 949&& Unsafe.Add(ref rA, 2) == Unsafe.Add(ref rB, 2) 950&& Unsafe.Add(ref rA, 3) == Unsafe.Add(ref rB, 3); 1432Vector128<byte> srcVec = Unsafe.As<Guid, Vector128<byte>>(ref value);

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

35Unsafe.AsRef(in g._c) = (short)((g._c & ~VersionMask) | RandomGuidVersion); 37Unsafe.AsRef(in g._d) = (byte)((g._d & ~ClockSeqHiAndReservedMask) | ClockSeqHiAndReservedValue);

src\libraries\System.Private.CoreLib\src\System\Half.cs (7)

749uint realMask = (uint)(Unsafe.BitCast<bool, sbyte>(float.IsNaN(value)) - 1); 1078uint subnormalMask = (uint)-Unsafe.BitCast<bool, byte>(offsetExponent == 0u); 1080int infinityOrNaNMask = Unsafe.BitCast<bool, byte>(offsetExponent == HalfExponentMask); 1373Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 1391Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 1415Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand); 1439Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);

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

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

804sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - Size); 807result = Unsafe.ReadUnaligned<Int128>(ref sourceRef); 823result |= Unsafe.Add(ref sourceRef, i); 887result = Unsafe.ReadUnaligned<Int128>(ref sourceRef); 905result |= Unsafe.Add(ref sourceRef, i); 956Unsafe.WriteUnaligned(ref address, upper); 957Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref address, sizeof(ulong)), lower); 985Unsafe.WriteUnaligned(ref address, lower); 986Unsafe.WriteUnaligned(ref Unsafe.AddByteOffset(ref address, sizeof(ulong)), upper);

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

348sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(short)); 351result = Unsafe.ReadUnaligned<short>(ref sourceRef); 424result = Unsafe.ReadUnaligned<short>(ref sourceRef); 471Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value); 489Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);

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

362sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(int)); 365result = Unsafe.ReadUnaligned<int>(ref sourceRef); 381result |= Unsafe.Add(ref sourceRef, i); 445result = Unsafe.ReadUnaligned<int>(ref sourceRef); 463result |= Unsafe.Add(ref sourceRef, i); 504Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value); 522Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);

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

359sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(long)); 362result = Unsafe.ReadUnaligned<long>(ref sourceRef); 378result |= Unsafe.Add(ref sourceRef, i); 442result = Unsafe.ReadUnaligned<long>(ref sourceRef); 460result |= Unsafe.Add(ref sourceRef, i); 501Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value); 519Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);

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

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

360MemoryStream mStream = Unsafe.As<MemoryStream>(_stream); 464return 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)

58p0 += Unsafe.ReadUnaligned<uint>(ref data); 59uint nextUInt32 = Unsafe.ReadUnaligned<uint>(ref Unsafe.AddByteOffset(ref data, 4)); 74data = ref Unsafe.AddByteOffset(ref data, 8); 95p0 += Unsafe.ReadUnaligned<uint>(ref data); 110uint partialResult = Unsafe.ReadUnaligned<uint>(ref Unsafe.Add(ref Unsafe.AddByteOffset(ref data, (nuint)count & 7), -4)); 176partialResult = Unsafe.AddByteOffset(ref data, (nuint)count & 2); 202partialResult |= (uint)Unsafe.ReadUnaligned<ushort>(ref data); 206partialResult |= (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 (18)

190Unsafe.As<Memory<T>, ReadOnlyMemory<T>>(ref memory); 278ref T refToReturn = ref Unsafe.NullRef<T>(); 290refToReturn = ref Unsafe.As<char, T>(ref Unsafe.As<string>(tmpObject).GetRawStringData()); 291lengthOfUnderlyingSpan = Unsafe.As<string>(tmpObject).Length; 307refToReturn = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject)); 308lengthOfUnderlyingSpan = Unsafe.As<T[]>(tmpObject).Length; 319Span<T> memoryManagerSpan = Unsafe.As<MemoryManager<T>>(tmpObject).GetSpan(); 346refToReturn = ref Unsafe.Add(ref refToReturn, (IntPtr)(void*)desiredStartIndex); 403ref char stringData = ref Unsafe.Add(ref s.GetRawStringData(), _index); 404return new MemoryHandle(Unsafe.AsPointer(ref stringData), handle); 415void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index & ReadOnlyMemory<T>.RemoveFlagsBitMask); 422void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index); 429return Unsafe.As<MemoryManager<T>>(tmpObject).Pin(_index);

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

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

1812Unsafe.CopyBlockUnaligned( 1814ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(typeof(TChar) == typeof(char) ? TwoDigitsCharsAsBytes : TwoDigitsBytes), (uint)sizeof(TChar) * 2 * value), 1832Unsafe.CopyBlockUnaligned( 1834ref Unsafe.Add(ref charsArray, (uint)sizeof(TChar) * 2 * value), 1837Unsafe.CopyBlockUnaligned( 1839ref 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\Numerics\BitOperations.cs (9)

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

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

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

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

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

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

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

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

28internal ref Impl AsImpl() => ref Unsafe.As<Matrix4x4, Impl>(ref this); 32internal readonly ref readonly Impl AsROImpl() => ref Unsafe.As<Matrix4x4, Impl>(ref Unsafe.AsRef(in this)); 38public ref Matrix4x4 AsM4x4() => ref Unsafe.As<Impl, Matrix4x4>(ref this); 96return Unsafe.Add(ref Unsafe.AsRef(in this.X), row)[column]; 106Unsafe.Add(ref this.X, row)[column] = value; 1230rotation = Quaternion.CreateFromRotationMatrix(Unsafe.As<Impl, Matrix4x4>(ref matTemp));

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

200return Unsafe.BitCast<Vector128<float>, Quaternion>(result);

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

51ref float address = ref Unsafe.AsRef(in quaternion.X); 52return Unsafe.Add(ref address, index); 59Unsafe.Add(ref quaternion.X, index) = value;

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

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

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

54this = Unsafe.ReadUnaligned<Vector2>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 592Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this); 620Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this); 634Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this); 648Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this); 674return Vector64.LoadUnsafe(ref Unsafe.AsRef(in X)).Equals(Vector64.LoadUnsafe(ref other.X));

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

51ref float address = ref Unsafe.AsRef(in vector.X); 52return Unsafe.Add(ref address, index); 59Unsafe.Add(ref vector.X, index) = value;

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

67this = Unsafe.ReadUnaligned<Vector3>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 601Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this); 629Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this); 643Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this); 657Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);

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

51ref float address = ref Unsafe.AsRef(in vector.X); 52return Unsafe.Add(ref address, index); 59Unsafe.Add(ref vector.X, index) = value;

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

81this = Unsafe.ReadUnaligned<Vector4>(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(values))); 700Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[0]), this); 728Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref array[index]), this); 742Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this); 756Unsafe.WriteUnaligned(ref Unsafe.As<float, byte>(ref MemoryMarshal.GetReference(destination)), this);

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

51ref float address = ref Unsafe.AsRef(in vector.X); 52return Unsafe.Add(ref address, index); 59Unsafe.Add(ref vector.X, index) = value;

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

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

142Unsafe.WriteUnaligned(

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

200ref T refToReturn = ref Unsafe.NullRef<T>(); 212refToReturn = ref Unsafe.As<char, T>(ref Unsafe.As<string>(tmpObject).GetRawStringData()); 213lengthOfUnderlyingSpan = Unsafe.As<string>(tmpObject).Length; 229refToReturn = ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject)); 230lengthOfUnderlyingSpan = Unsafe.As<T[]>(tmpObject).Length; 241Span<T> memoryManagerSpan = Unsafe.As<MemoryManager<T>>(tmpObject).GetSpan(); 268refToReturn = ref Unsafe.Add(ref refToReturn, (IntPtr)(void*)desiredStartIndex); 318ref char stringData = ref Unsafe.Add(ref s.GetRawStringData(), _index); 319return new MemoryHandle(Unsafe.AsPointer(ref stringData), handle); 330void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index & RemoveFlagsBitMask); 337void* pointer = Unsafe.Add<T>(Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(Unsafe.As<T[]>(tmpObject))), _index); 344return Unsafe.As<MemoryManager<T>>(tmpObject).Pin(_index);

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

84_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */); 120_reference = ref Unsafe.AsRef(in reference); 151return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */); 228return new ReadOnlySpan<T>(ref Unsafe.As<TDerived, T>(ref items._reference), items.Length); 281ref T ret = ref Unsafe.NullRef<T>(); 337Unsafe.AreSame(ref left._reference, ref right._reference); 347return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length)); 365return new ReadOnlySpan<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start); 388return 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)

324copyOfArgs = new(ref Unsafe.AsRef<object?>(pArgStorage), _argCount); 355copyOfArgs = new(ref Unsafe.AsRef<object?>(pStorage), _argCount); 376ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i).GetRawData()) : 377ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i));

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

126return Volatile.Read(ref Unsafe.As<byte, object>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset))); 137ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)); 143(void*)Unsafe.As<byte, IntPtr>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 147return Volatile.Read(ref Unsafe.As<IntPtr, object>(ref *(IntPtr*)_addressOrOffset)); 154return RuntimeHelpers.Box(_methodTable, ref Unsafe.AsRef<byte>(_addressOrOffset.ToPointer())); 160ref Unsafe.As<IntPtr, object>(ref *(IntPtr*)_addressOrOffset).GetRawData()); 163return Pointer.Box((void*)Unsafe.As<byte, IntPtr>( 164ref Unsafe.AsRef<byte>(_addressOrOffset.ToPointer())), _fieldInfo.FieldType); 218ref Unsafe.As<byte, object?>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 226ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset), 234ref Unsafe.As<byte, short>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 235Unsafe.As<byte, short>(ref value!.GetRawData())); 242ref Unsafe.As<byte, int>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 243Unsafe.As<byte, int>(ref value!.GetRawData())); 250ref Unsafe.As<byte, long>(ref Unsafe.AddByteOffset(ref obj.GetRawData(), _addressOrOffset)), 251Unsafe.As<byte, long>(ref value!.GetRawData())); 256Volatile.Write(ref Unsafe.As<IntPtr, object?>(ref *(IntPtr*)_addressOrOffset), value); 262ref Unsafe.AsRef<byte>(_addressOrOffset.ToPointer()), 269ref Unsafe.AsRef<short>(_addressOrOffset.ToPointer()), 270Unsafe.As<byte, short>(ref value!.GetRawData())); 276ref Unsafe.AsRef<int>(_addressOrOffset.ToPointer()), 277Unsafe.As<byte, int>(ref value!.GetRawData())); 283ref Unsafe.AsRef<long>(_addressOrOffset.ToPointer()), 284Unsafe.As<byte, long>(ref value!.GetRawData()));

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

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

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

209copyOfArgs = new(ref Unsafe.AsRef<object?>(pArgStorage), _argCount); 244copyOfArgs = new(ref Unsafe.AsRef<object?>(pStorage), _argCount); 262ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i).GetRawData()) : 263ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i));

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

377copyOfArgs = new(ref Unsafe.AsRef<object?>(pArgStorage), _argCount); 408copyOfArgs = new(ref Unsafe.AsRef<object?>(pStorage), _argCount); 429ByReference.Create(ref Unsafe.AsRef<object>(pStorage + i).GetRawData()) : 430ByReference.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 (3)

528value = Unsafe.As<TValue>(secondary); 579key = Unsafe.As<TKey>(oKey); 580value = Unsafe.As<TValue>(oValue);

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)

110return ref Unsafe.As<byte, Entry>(ref Unsafe.As<RawArrayData>(table).Data); 136return 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 (8)

17_ptr = Unsafe.AsPointer(ref s); 33return new ObjectHandleOnStack(Unsafe.AsPointer(ref o)); 44_ptr = Unsafe.AsPointer(ref stackMark); 56_ptr = Unsafe.AsPointer(ref module); 62_ptr = Unsafe.AsPointer(ref module); 75_ptr = Unsafe.AsPointer(ref assembly); 88_ptr = Unsafe.AsPointer(ref type); 94_ptr = Unsafe.AsPointer(ref rth);

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

53dest = Unsafe.As<T[]>(Array.CreateInstanceFromArrayType(array.GetType(), length)); 63ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), offset),

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

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

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

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

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

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

169void* pRawData = Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(arr)); 178void* pRawData = Unsafe.AsPointer(ref MemoryMarshal.GetArrayDataReference(arr)); 317return Unsafe.ReadUnaligned<short>(addr); 341return Unsafe.ReadUnaligned<int>(addr); 388return Unsafe.ReadUnaligned<long>(addr); 428Unsafe.WriteUnaligned(addr, val); 461Unsafe.WriteUnaligned(addr, val); 512Unsafe.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 (5)

258Unsafe.SkipInit(out ComVariant variant); 382ArgumentOutOfRangeException.ThrowIfGreaterThan(Unsafe.SizeOf<T>(), sizeof(UnionTypes), nameof(T)); 396Unsafe.SkipInit(out ComVariant value); 574ArgumentOutOfRangeException.ThrowIfGreaterThan(Unsafe.SizeOf<T>(), sizeof(UnionTypes), nameof(T)); 579return 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)

43if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 103if (Unsafe.IsNullRef(ref MemoryMarshal.GetReference(managed))) 148return (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 (24)

39ref Unsafe.As<T, byte>(ref GetReference(span)), 62ref Unsafe.As<T, byte>(ref GetReference(span)), 76Unsafe.As<ReadOnlyMemory<T>, Memory<T>>(ref memory); 95internal 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); 102internal 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); 127uint fromSize = (uint)Unsafe.SizeOf<TFrom>(); 128uint toSize = (uint)Unsafe.SizeOf<TTo>(); 155ref Unsafe.As<TFrom, TTo>(ref span._reference), 182uint fromSize = (uint)Unsafe.SizeOf<TFrom>(); 183uint toSize = (uint)Unsafe.SizeOf<TTo>(); 210ref Unsafe.As<TFrom, TTo>(ref GetReference(span)), 229new Span<T>(ref Unsafe.AsRef(in reference), length); 246new ReadOnlySpan<T>(ref Unsafe.AsRef(in reference), length); 292segment = new ArraySegment<T>(Unsafe.As<T[]>(obj), index & ReadOnlyMemory<T>.RemoveFlagsBitMask, length); 301if (Unsafe.As<MemoryManager<T>>(obj).TryGetArray(out ArraySegment<T> tempArraySegment)) 413T[] array = Unsafe.As<T[]>(obj); 481return Unsafe.ReadUnaligned<T>(ref GetReference(source)); 501value = Unsafe.ReadUnaligned<T>(ref GetReference(source)); 520Unsafe.WriteUnaligned(ref GetReference(destination), value); 539Unsafe.WriteUnaligned(ref GetReference(destination), value); 562return ref Unsafe.As<byte, T>(ref GetReference(span)); 584return 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)); 1064Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 1088Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 1112Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand); 1136Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand); 1923Unsafe.SkipInit(out result); 1924return NativeType.TryParse(utf8Text, style, provider, out Unsafe.As<NFloat, NativeType>(ref result));

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

197SpanHelpers.Memmove(ref Unsafe.As<T, byte>(ref value), ref *ptr, sizeofT); 251Buffer.Memmove(ref Unsafe.Add(ref structure, i), ref Unsafe.AsRef<T>(ptr + alignedSizeofT * i), 1); 284SpanHelpers.Memmove(ref *ptr, ref Unsafe.As<T, byte>(ref value), sizeofT); 339Buffer.Memmove(ref Unsafe.AsRef<T>(ptr + alignedSizeofT * i), ref Unsafe.Add(ref structure, i), 1);

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

213Unsafe.SkipInit(out TSelf result);

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

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

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

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

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

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

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

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

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

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

70Unsafe.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 (105)

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

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

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

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

348result = (sbyte)Unsafe.Add(ref MemoryMarshal.GetReference(source), source.Length - sizeof(sbyte)); 432Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value); 450Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);

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

21Debug.Assert(Unsafe.SizeOf<T>() == Unsafe.SizeOf<TImpl>()); 38SpanHelpers.NonPackedIndexOfValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length); 42SpanHelpers.NonPackedIndexOfValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length); 46SpanHelpers.LastIndexOfValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, span.Length); 50SpanHelpers.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 (6)

21Debug.Assert(Unsafe.SizeOf<T>() == Unsafe.SizeOf<TImpl>()); 38SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length); 42SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length); 46SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length); 50SpanHelpers.LastIndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, span.Length);

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

21Debug.Assert(Unsafe.SizeOf<T>() == Unsafe.SizeOf<TImpl>()); 38SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.DontNegate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length); 42SpanHelpers.NonPackedIndexOfAnyValueType<TImpl, SpanHelpers.Negate<TImpl>>(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length); 46SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, span.Length); 50SpanHelpers.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 (6)

21Debug.Assert(Unsafe.SizeOf<T>() == Unsafe.SizeOf<TImpl>()); 41SpanHelpers.IndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length); 45SpanHelpers.IndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length); 49SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, span.Length); 53SpanHelpers.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 (6)

21Debug.Assert(Unsafe.SizeOf<T>() == Unsafe.SizeOf<TImpl>()); 42SpanHelpers.IndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length); 46SpanHelpers.IndexOfAnyExceptValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length); 50SpanHelpers.LastIndexOfAnyValueType(ref Unsafe.As<T, TImpl>(ref MemoryMarshal.GetReference(span)), _e0, _e1, _e2, _e3, _e4, span.Length); 54SpanHelpers.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)

33ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 41ref Unsafe.As<char, short>(ref MemoryMarshal.GetReference(span)), span.Length, ref _state); 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);

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)

90return Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(hashEntries), (nuint)offset) == value; 100ref Unsafe.As<ProbabilisticMap, uint>(ref Map), 236ref char searchSpaceEnd = ref Unsafe.Add(ref searchSpace, searchSpaceLength); 246while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd)) 251return (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref cur) / sizeof(char)); 254cur = ref Unsafe.Add(ref cur, 1); 259while (!Unsafe.AreSame(ref cur, ref searchSpaceEnd)) 264return (int)((nuint)Unsafe.ByteOffset(ref searchSpace, ref cur) / sizeof(char)); 267cur = ref Unsafe.Add(ref cur, 1); 288char c = Unsafe.Add(ref searchSpace, searchSpaceLength); 299char c = Unsafe.Add(ref searchSpace, searchSpaceLength);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

726Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 744Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), exponent); 768Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand); 792Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), significand);

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

89_reference = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(array), (nint)(uint)start /* force zero-extension */); 156return ref Unsafe.Add(ref _reference, (nint)(uint)index /* force zero-extension */); 274ref T ret = ref Unsafe.NullRef<T>(); 287SpanHelpers.ClearWithReferences(ref Unsafe.As<T, IntPtr>(ref _reference), (uint)_length * (nuint)(sizeof(T) / sizeof(nuint))); 291SpanHelpers.ClearWithoutReferences(ref Unsafe.As<T, byte>(ref _reference), (uint)_length * (nuint)sizeof(T)); 355Unsafe.AreSame(ref left._reference, ref right._reference); 371return new string(new ReadOnlySpan<char>(ref Unsafe.As<T, char>(ref _reference), _length)); 389return new Span<T>(ref Unsafe.Add(ref _reference, (nint)(uint)start /* force zero-extension */), _length - start); 417return 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 (418)

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

29ref Unsafe.As<char, byte>(ref strA.GetRawStringData()), 30ref Unsafe.As<char, byte>(ref strB.GetRawStringData()), 44ref Unsafe.Add(ref strA.GetRawStringData(), (nint)(uint)indexA /* force zero-extension */), countA, 45ref Unsafe.Add(ref strB.GetRawStringData(), (nint)(uint)indexB /* force zero-extension */), countB); 420return Ordinal.CompareStringIgnoreCase(ref Unsafe.Add(ref strA.GetRawStringData(), indexA), lengthA, ref Unsafe.Add(ref strB.GetRawStringData(), indexB), lengthB); 569Ordinal.EqualsIgnoreCase(ref Unsafe.Add(ref GetRawStringData(), Length - value.Length), 604return Unsafe.Add(ref _firstChar, (nint)localLength - 1) == value; 757return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref _firstChar), (uint)_stringLength * 2 /* in bytes, not chars */, (uint)seed, (uint)(seed >> 32)); 778return Marvin.ComputeHash32(ref Unsafe.As<char, byte>(ref MemoryMarshal.GetReference(value)), (uint)value.Length * 2 /* in bytes, not chars */, (uint)seed, (uint)(seed >> 32)); 986ref Unsafe.As<char, byte>(ref this.GetRawStringData()), 987ref Unsafe.As<char, byte>(ref value.GetRawStringData()),

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

113source: ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(value), startIndex)); 382slice = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, (nint)(uint)startIndex /* force zero-extension */), count); 423destination: ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(destination), destinationIndex), 424source: ref Unsafe.Add(ref _firstChar, sourceIndex), 493source: ref Unsafe.Add(ref _firstChar, startIndex), 524internal ref ushort GetRawStringDataAsUInt16() => ref Unsafe.As<char, ushort>(ref _firstChar); 568Unsafe.Add(ref result._firstChar, 1) = c2; 748return 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); 109int result = SpanHelpers.IndexOfChar(ref Unsafe.Add(ref _firstChar, startIndex), value, count); 149int result = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, startIndex), count).IndexOfAny(anyOf); 294=> SpanHelpers.LastIndexOfValueType(ref Unsafe.As<char, short>(ref _firstChar), (short)value, Length); 319int result = SpanHelpers.LastIndexOfValueType(ref Unsafe.As<char, short>(ref Unsafe.Add(ref _firstChar, startSearchAt)), (short)value, count); 367int result = new ReadOnlySpan<char>(ref Unsafe.Add(ref _firstChar, startSearchAt), count).LastIndexOfAny(anyOf);

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

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

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

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

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

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

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

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

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

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

340ref Unsafe.Add(ref result.GetRawStringData(), chunkOffset), 787Append(ref Unsafe.Add(ref value.GetRawStringData(), startIndex), count); 1237Debug.Assert(!Unsafe.IsNullRef(ref separator)); 2276ref char destination = ref Unsafe.Add(ref MemoryMarshal.GetArrayDataReference(chunkChars), chunkLength); 2282Unsafe.Add(ref destination, 1) = Unsafe.Add(ref value, 1); 2323new ReadOnlySpan<char>(ref Unsafe.Add(ref value, firstLength), restLength).CopyTo(m_ChunkChars); 2490value = ref Unsafe.Add(ref value, lengthToCopy);

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

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

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

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

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

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

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

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

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

737Unsafe.WriteUnaligned(longBytes, *longChars); 1401Unsafe.WriteUnaligned(longChars, *longBytes);

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

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

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

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

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

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

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

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

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

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

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

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

80internal bool IsNull => Unsafe.IsNullRef(ref _value) && _type == IntPtr.Zero;

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

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

322sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(ushort)); 325result = Unsafe.ReadUnaligned<ushort>(ref sourceRef); 373result = Unsafe.ReadUnaligned<ushort>(ref sourceRef); 403Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value); 421Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);

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

337sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(uint)); 340result = Unsafe.ReadUnaligned<uint>(ref sourceRef); 356result |= Unsafe.Add(ref sourceRef, i); 395result = Unsafe.ReadUnaligned<uint>(ref sourceRef); 412uint part = Unsafe.Add(ref sourceRef, i); 435Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value); 453Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);

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

336sourceRef = ref Unsafe.Add(ref sourceRef, source.Length - sizeof(ulong)); 339result = Unsafe.ReadUnaligned<ulong>(ref sourceRef); 355result |= Unsafe.Add(ref sourceRef, i); 394result = Unsafe.ReadUnaligned<ulong>(ref sourceRef); 411ulong part = Unsafe.Add(ref sourceRef, i); 434Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value); 452Unsafe.WriteUnaligned(ref MemoryMarshal.GetReference(destination), value);

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

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

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

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

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\GC.CoreCLR.cs (3)

781return Unsafe.As<T[]>(AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags)); 799return Unsafe.As<T[]>(AllocateNewArray(RuntimeTypeHandle.ToIntPtr(typeof(T[]).TypeHandle), length, flags)); 832ref GCConfigurationContext context = ref Unsafe.As<byte, GCConfigurationContext>(ref *(byte*)configurationContext);

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

57MulticastDelegate d = Unsafe.As<MulticastDelegate>(obj);

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

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

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

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

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

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

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

262ref Unsafe.As<RawData>(obj).Data; 272rawSize += (uint)Unsafe.As<RawArrayData>(obj).Length * (nuint)pMT->ComponentSize; 293return ref Unsafe.As<byte, int>(ref Unsafe.As<RawArrayData>(array).Data); 344return (MethodTable*)Unsafe.Add(ref Unsafe.As<byte, IntPtr>(ref obj.GetRawData()), -1); 458return Unsafe.As<byte, object?>(ref target); 473/// This API returns the same value as <see cref="Unsafe.SizeOf{T}"/> for the type that <paramref name="type"/> represents.

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

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

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

262structMarshalStub(ref structure.GetRawData(), (byte*)ptr, MarshalOperation.Cleanup, ref Unsafe.NullRef<CleanupWorkListElement?>()); 265structMarshalStub(ref structure.GetRawData(), (byte*)ptr, MarshalOperation.Marshal, ref Unsafe.NullRef<CleanupWorkListElement?>()); 290structMarshalStub(ref structure.GetRawData(), (byte*)ptr, MarshalOperation.Unmarshal, ref Unsafe.NullRef<CleanupWorkListElement?>()); 324structMarshalStub(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\RuntimeType.CoreCLR.cs (2)

2429return Unsafe.As<RuntimeTypeCache>(cache); 2446return Unsafe.As<RuntimeTypeCache>(cache);

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

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

src\System\StubHelpers.cs (3)

504if (Unsafe.IsNullRef(ref cleanupWorkList)) 1571structMarshalStub(ref obj.GetRawData(), pNative, MarshalOperation.Unmarshal, ref Unsafe.NullRef<CleanupWorkListElement?>()); 1590structMarshalStub(ref obj.GetRawData(), pNative, MarshalOperation.Cleanup, ref Unsafe.NullRef<CleanupWorkListElement?>());

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

97if (Unsafe.IsNullRef(ref location1)) 119Unsafe.As<T>(Exchange(ref Unsafe.As<T, object?>(ref location1), value)); 178if (Unsafe.IsNullRef(ref location1)) 208Unsafe.As<T>(CompareExchange(ref Unsafe.As<T, object?>(ref location1), value, comparand)); 266CompareExchange(ref Unsafe.AsRef(in location), 0, 0);

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

46result = 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);