MonoMod.Backports

Indicates that certain members on a specified are accessed dynamically, for example through .

This allows tools to understand which members are being accessed during the execution of a program. This attribute is valid on members whose type is or . When this attribute is applied to a location of type , the assumption is that the string represents a fully qualified type name. When this attribute is applied to a class, interface, or struct, the members specified can be accessed dynamically on instances returned from calling on instances of that class, interface, or struct. If the attribute is applied to a method it's treated as a special case and it implies the attribute should be applied to the "this" parameter of the method. As such the attribute should only be used on instance methods of types assignable to System.Type (or string, but no methods will use it there).

Initializes a new instance of the class with the specified member types.

The types of members dynamically accessed.

Gets the which specifies the type of members dynamically accessed.

Specifies the types of members that are dynamically accessed. This enumeration has a attribute that allows a bitwise combination of its member values.

Specifies no members.

Specifies the default, parameterless public constructor.

Specifies all public constructors.

Specifies all non-public constructors.

Specifies all public methods.

Specifies all non-public methods.

Specifies all public fields.

Specifies all non-public fields.

Specifies all public nested types.

Specifies all non-public nested types.

Specifies all public properties.

Specifies all non-public properties.

Specifies all public events.

Specifies all non-public events.

Specifies all members.

Used to indicate a byref escapes and is not scoped.

There are several cases where the C# compiler treats a as implicitly - where the compiler does not allow the to escape the method. For example: for instance methods. parameters that refer to types. parameters. This attribute is used in those instances where the should be allowed to escape. Applying this attribute, in any form, has impact on consumers of the applicable API. It is necessary for API authors to understand the lifetime implications of applying this attribute and how it may impact their users.

Initializes a new instance of the class.

Reserved to be used by the compiler for tracking metadata. This class should not be used by developers in source code.

This definition is provided by the IsExternalInit NuGet package (https://www.nuget.org/packages/IsExternalInit). Please see https://github.com/manuelroemer/IsExternalInit for more information.

Provides a handler used by the language compiler to process interpolated strings into instances.

Expected average length of formatted data used for an individual interpolation expression result.

This is inherited from string.Format, and could be changed based on further data. string.Format actually uses `format.Length + args.Length * 8`, but format.Length includes the format items themselves, e.g. "{0}", and since it's rare to have double-digit numbers of items, we bump the 8 up to 11 to account for the three extra characters in "{d}", since the compiler-provided base length won't include the equivalent character count.

Minimum size array to rent from the pool.

Same as stack-allocation size used today by string.Format.

Optional provider to pass to IFormattable.ToString or ISpanFormattable.TryFormat calls.

Array rented from the array pool and used to back .

The span to write into.

Position at which to write the next character.

Whether provides an ICustomFormatter.

Custom formatters are very rare. We want to support them, but it's ok if we make them more expensive in order to make them as pay-for-play as possible. So, we avoid adding another reference type field to reduce the size of the handler and to reduce required zero'ing, by only storing whether the provider provides a formatter, rather than actually storing the formatter. This in turn means, if there is a formatter, we pay for the extra interface call on each AppendFormatted that needs it.

Creates a handler used to translate an interpolated string into a .

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.

Creates a handler used to translate an interpolated string into a .

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. An object that supplies culture-specific formatting information. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.

Creates a handler used to translate an interpolated string into a .

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string. An object that supplies culture-specific formatting information. A buffer temporarily transferred to the handler for use as part of its formatting. Contents may be overwritten. This is intended to be called only by compiler-generated code. Arguments are not validated as they'd otherwise be for members intended to be used directly.

Derives a default length with which to seed the handler.

The number of constant characters outside of interpolation expressions in the interpolated string. The number of interpolation expressions in the interpolated string.

Gets the built .

The built string.

Gets the built and clears the handler.

The built string. This releases any resources used by the handler. The method should be invoked only once and as the last thing performed on the handler. Subsequent use is erroneous, ill-defined, and may destabilize the process, as may using any other copies of the handler after ToStringAndClear is called on any one of them.

Clears the handler, returning any rented array to the pool.

Gets a span of the written characters thus far.

Writes the specified string to the handler.

The string to write.

Writes the specified string to the handler.

The string to write.

Writes the specified value to the handler.

The value to write. The type of the value to write.

Writes the specified value to the handler.

The value to write. The format string. The type of the value to write.

Writes the specified value to the handler.

The value to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The type of the value to write.

Writes the specified value to the handler.

The value to write. The format string. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The type of the value to write.

Writes the specified character span to the handler.

The span to write.

Writes the specified string of chars to the handler.

The span to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The format string.

Writes the specified value to the handler.

The value to write.

Writes the specified value to the handler.

The value to write. Slow path to handle a custom formatter, potentially null value, or a string that doesn't fit in the current buffer.

Writes the specified value to the handler.

The value to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The format string.

Writes the specified value to the handler.

The value to write. Minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value. The format string.

Gets whether the provider provides a custom formatter.

Formats the value using the custom formatter from the provider.

The value to write. The format string. The type of the value to write.

Handles adding any padding required for aligning a formatted value in an interpolation expression.

The position at which the written value started. Non-zero minimum number of characters that should be written for this value. If the value is negative, it indicates left-aligned and the required minimum is the absolute value.

Ensures has the capacity to store beyond .

Fallback for fast path in when there's not enough space in the destination.

The string to write.

Fallback for for when not enough space exists in the current buffer.

The span to write.

Grows to have the capacity to store at least beyond .

Grows the size of .

Grow the size of to at least the specified .

Disables the built-in runtime managed/unmanaged marshalling subsystem for P/Invokes, Delegate types, and unmanaged function pointer invocations.

Note: This does nothing on runtimes older than .NET 7. It is provided entirely for forward compatibility. The built-in marshalling subsystem has some behaviors that cannot be changed due to backward-compatibility requirements. This attribute allows disabling the built-in subsystem and instead uses the following rules for P/Invokes, Delegates, and unmanaged function pointer invocations: - All value types that do not contain reference type fields recursively (unmanaged in C#) are blittable - Value types that recursively have any fields that have [StructLayout(LayoutKind.Auto)] are disallowed from interop. - All reference types are disallowed from usage in interop scenarios. - SetLastError support in P/Invokes is disabled. - varargs support is disabled. - LCIDConversionAttribute support is disabled.

Indicates the attributed type is to be used as an interpolated string handler.

Initializes the .

Indicates which arguments to a method involving an interpolated string handler should be passed to that handler.

Initializes a new instance of the class.

The name of the argument that should be passed to the handler. may be used as the name of the receiver in an instance method.

Initializes a new instance of the class.

The names of the arguments that should be passed to the handler. may be used as the name of the receiver in an instance method.

Gets the names of the arguments that should be passed to the handler.

may be used as the name of the receiver in an instance method.

This interface is required for types that want to be indexed into by dynamic patterns.

The number of positions in this data structure.

Get the element at position .

Used to indicate to the compiler that a method should be called in its containing module's initializer.

When one or more valid methods with this attribute are found in a compilation, the compiler will emit a module initializer which calls each of the attributed methods. Certain requirements are imposed on any method targeted with this attribute: - The method must be `static`. - The method must be an ordinary member method, as opposed to a property accessor, constructor, local function, etc. - The method must be parameterless. - The method must return `void`. - The method must not be generic or be contained in a generic type. - The method's effective accessibility must be `internal` or `public`. The specification for module initializers in the .NET runtime can be found here: https://github.com/dotnet/runtime/blob/main/docs/design/specs/Ecma-335-Augments.md#module-initializer

Provides a collection of methods for interoperating with , , , and .

Provides a collection of methods for interoperating with , , , and .

Get an array segment from the underlying memory. If unable to get the array segment, return false with a default array segment.

Gets an from the underlying read-only memory. If unable to get the type, returns false.

The element type of the . The type of to try and retrive. The memory to get the manager for. The returned manager of the . A indicating if it was successful.

Gets an and , from the underlying read-only memory. If unable to get the type, returns false.

The element type of the . The type of to try and retrive. The memory to get the manager for. The returned manager of the . The offset from the start of the that the represents. The length of the that the represents. A indicating if it was successful.

Creates an view of the given to allow the to be used in existing APIs that take an .

The element type of the . The ReadOnlyMemory to view as an An view of the given

Attempts to get the underlying from a .

The memory that may be wrapping a object. The string. The starting location in . The number of items in .

Reads a structure of type T out of a read-only span of bytes.

Reads a structure of type T out of a span of bytes. If the span is too small to contain the type T, return false.

Writes a structure of type T into a span of bytes.

Writes a structure of type T into a span of bytes. If the span is too small to contain the type T, return false.

Creates a new memory over the portion of the pre-pinned target array beginning at 'start' index and ending at 'end' index (exclusive).

The pre-pinned target array. The index at which to begin the memory. The number of items in the memory. This method should only be called on an array that is already pinned and that array should not be unpinned while the returned Memory is still in use. Calling this method on an unpinned array could result in memory corruption. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Casts a Span of one primitive type to Span of bytes. That type may not contain pointers or references. This is checked at runtime in order to preserve type safety.

The source slice, of type . Thrown when contains pointers. Thrown if the Length property of the new Span would exceed Int32.MaxValue.

Casts a ReadOnlySpan of one primitive type to ReadOnlySpan of bytes. That type may not contain pointers or references. This is checked at runtime in order to preserve type safety.

The source slice, of type . Thrown when contains pointers. Thrown if the Length property of the new Span would exceed Int32.MaxValue.

Creates a from a .

The . A representing the same memory as the , but writable. must be used with extreme caution. is used to represent immutable data and other memory that is not meant to be written to; instances created by should not be written to. The method exists to enable variables typed as but only used for reading to store a .

Returns a reference to the 0th element of the Span. If the Span is empty, returns a reference to the location where the 0th element would have been stored. Such a reference can be used for pinning but must never be dereferenced.

Returns a reference to the 0th element of the ReadOnlySpan. If the Span is empty, returns a reference to the location where the 0th element would have been stored. Such a reference can be used for pinning but must never be dereferenced.

Casts a Span of one primitive type to another primitive type . These types may not contain pointers or references. This is checked at runtime in order to preserve type safety.

Supported only for platforms that support misaligned memory access. The source slice, of type . Thrown when or contains pointers.

Casts a ReadOnlySpan of one primitive type to another primitive type . These types may not contain pointers or references. This is checked at runtime in order to preserve type safety.

Supported only for platforms that support misaligned memory access. The source slice, of type . Thrown when or contains pointers.

Provides a collection of methods for interoperating with

Get from the underlying . If unable to get the , return false.

Get an array segment from the underlying . If unable to get the array segment, return false with a default array segment.

Get from the underlying . If unable to get the , return false.

Get from the underlying . If unable to get the , return false.

Extensions to providing consistent access to APIs introduced after the type.

Provides a resource pool that enables reusing instances of arrays.

Renting and returning buffers with an can increase performance in situations where arrays are created and destroyed frequently, resulting in significant memory pressure on the garbage collector. This class is thread-safe. All members may be used by multiple threads concurrently.

Retrieves a shared instance.

The shared pool provides a default implementation of that's intended for general applicability. It maintains arrays of multiple sizes, and may hand back a larger array than was actually requested, but will never hand back a smaller array than was requested. Renting a buffer from it with will result in an existing buffer being taken from the pool if an appropriate buffer is available or in a new buffer being allocated if one is not available. byte[] and char[] are the most commonly pooled array types. For these we use a special pool type optimized for very fast access speeds, at the expense of more memory consumption. The shared pool instance is created lazily on first access.

Creates a new instance using default configuration options.

A new instance.

Creates a new instance using custom configuration options.

The maximum length of array instances that may be stored in the pool. The maximum number of array instances that may be stored in each bucket in the pool. The pool groups arrays of similar lengths into buckets for faster access. A new instance with the specified configuration options. The created pool will group arrays into buckets, with no more than in each bucket and with those arrays not exceeding in length.

Retrieves a buffer that is at least the requested length.

The minimum length of the array needed. An array that is at least in length. This buffer is loaned to the caller and should be returned to the same pool via so that it may be reused in subsequent usage of . It is not a fatal error to not return a rented buffer, but failure to do so may lead to decreased application performance, as the pool may need to create a new buffer to replace the one lost.

Returns to the pool an array that was previously obtained via on the same instance.

The buffer previously obtained from to return to the pool. If true and if the pool will store the buffer to enable subsequent reuse, will clear of its contents so that a subsequent consumer via will not see the previous consumer's content. If false or if the pool will release the buffer, the array's contents are left unchanged. Once a buffer has been returned to the pool, the caller gives up all ownership of the buffer and must not use it. The reference returned from a given call to must only be returned via once. The default may hold onto the returned buffer in order to rent it again, or it may release the returned buffer if it's determined that the pool already has enough buffers stored.

Extension methods for

Returns position of first occurrence of item in the

Copy the to the specified .

The source . The destination .

Converts the to an array

Writes contents of to

The default maximum length of each array in the pool (2^20).

The default maximum number of arrays per bucket that are available for rent.

Gets an ID for the pool to use with events.

Provides a thread-safe bucket containing buffers that can be Rent'd and Return'd.

Creates the pool with numberOfBuffers arrays where each buffer is of bufferLength length.

Gets an ID for the bucket to use with events.

Takes an array from the bucket. If the bucket is empty, returns null.

Attempts to return the buffer to the bucket. If successful, the buffer will be stored in the bucket and true will be returned; otherwise, the buffer won't be stored, and false will be returned.

Represents a sink

Notifies that amount of data was written to /

Requests the that is at least in size if possible, otherwise returns maximum available memory. If is equal to 0, currently available memory would get returned.

Requests the that is at least in size if possible, otherwise returns maximum available memory. If is equal to 0, currently available memory would get returned.

Owner of Memory that is responsible for disposing the underlying memory appropriately.

Returns a Memory.

Provides a mechanism for pinning and unpinning objects to prevent the GC from moving them.

Call this method to indicate that the IPinnable object can not be moved by the garbage collector. The address of the pinned object can be taken. The offset to the element within the memory at which the returned points to.

Call this method to indicate that the IPinnable object no longer needs to be pinned. The garbage collector is free to move the object now.

A handle for the memory.

Creates a new memory handle for the memory.

pointer to memory reference to manually managed object, or default if there is no memory manager handle used to pin array buffers

Returns the pointer to memory, where the memory is assumed to be pinned and hence the address won't change.

Frees the pinned handle and releases IPinnable.

Manager of that provides the implementation.

Returns a .

Returns a span wrapping the underlying memory.

Returns a handle to the memory that has been pinned and hence its address can be taken.

The offset to the element within the memory at which the returned points to. (default = 0)

Lets the garbage collector know that the object is free to be moved now.

Returns a for the current .

The element count in the memory, starting at offset 0.

Returns a for the current .

The offset to the element which the returned memory starts at. The element count in the memory, starting at element offset .

Returns an array segment. Returns the default array segment if not overriden.

Implements IDisposable.

Clean up of any leftover managed and unmanaged resources.

Represents a sequence that can read a sequential series of .

Returns empty

Length of the .

Determines if the is empty.

Determines if the contains a single segment.

Gets from the first segment.

A position to the start of the .

A position to the end of the

Creates an instance of from linked memory list represented by start and end segments and corresponding indexes in them.

Creates an instance of from the .

Creates an instance of from the , start and index.

Creates an instance of from the . Consumer is expected to manage lifetime of memory until is not used anymore.

Forms a slice out of the given , beginning at , with items

The index at which to begin this slice. The length of the slice

Forms a slice out of the given , beginning at , ending at (inclusive).

The index at which to begin this slice. The end (inclusive) of the slice

Forms a slice out of the given , beginning at , with items

The starting (inclusive) at which to begin this slice. The length of the slice

Forms a slice out of the given , beginning at , with items

The index at which to begin this slice. The length of the slice

Forms a slice out of the given , beginning at , ending at (inclusive).

The index at which to begin this slice. The end (inclusive) of the slice

Forms a slice out of the given , beginning at ', with items

The starting (inclusive) at which to begin this slice. The length of the slice

Forms a slice out of the given , beginning at , ending at (inclusive).

The starting (inclusive) at which to begin this slice. The ending (inclusive) of the slice

Forms a slice out of the given , beginning at , ending at the existing 's end.

The starting (inclusive) at which to begin this slice.

Forms a slice out of the given , beginning at , ending at the existing 's end.

The start index at which to begin this slice.

Returns an enumerator over the

Returns a new at an from the start of the sequence.

Returns a new at an from the

Tries to retrieve next segment after and return its contents in . Returns false if end of was reached otherwise true. Sets to the beginning of next segment if is set to true.

An enumerator over the

Initialize the enumerator.

The to enumerate.

The current

Moves to the next in the

Represents a linked list of nodes.

The value for current node.

The next node.

The sum of node length before current.

Represents a standard formatting string without using an actual String. A StandardFormat consists of a character (such as 'G', 'D' or 'X') and an optional precision ranging from 0..99, or the special value NoPrecision.

Precision values for format that don't use a precision, or for when the precision is to be unspecified.

The maximum valid precision value.

The character component of the format.

The precision component of the format. Ranges from 0..9 or the special value NoPrecision.

true if Precision is a value other than NoPrecision

true if the StandardFormat == default(StandardFormat)

Create a StandardFormat.

A type-specific formatting character such as 'G', 'D' or 'X' An optional precision ranging from 0..9 or the special value NoPrecision (the default)

Converts a character to a StandardFormat using the NoPrecision precision.

Converts a classic .NET format string into a StandardFormat

Converts a classic .NET format string into a StandardFormat

Returns true if both the Symbol and Precision are equal.

Compute a hash code.

Returns true if both the Symbol and Precision are equal.

Returns the format in classic .NET format.

Returns true if both the Symbol and Precision are equal.

Returns false if both the Symbol and Precision are equal.

Provides an ArrayPool implementation meant to be used as the singleton returned from ArrayPool.Shared.

The implementation uses a tiered caching scheme, with a small per-thread cache for each array size, followed by a cache per array size shared by all threads, split into per-core stacks meant to be used by threads running on that core. Locks are used to protect each per-core stack, because a thread can migrate after checking its processor number, because multiple threads could interleave on the same core, and because a thread is allowed to check other core's buckets if its core's bucket is empty/full.

The number of buckets (array sizes) in the pool, one for each array length, starting from length 16.

Maximum number of per-core stacks to use per array size.

The maximum number of buffers to store in a bucket's global queue.

A per-thread array of arrays, to cache one array per array size per thread.

Used to keep track of all thread local buckets for trimming if needed.

An array of per-core array stacks. The slots are lazily initialized to avoid creating lots of overhead for unused array sizes.

Whether the callback to trim arrays in response to memory pressure has been created.

Allocate a new PerCoreLockedStacks and try to store it into the array.

Gets an ID for the pool to use with events.

Stores a set of stacks of arrays, with one stack per core.

Number of locked stacks to employ.

The stacks.

Initializes the stacks.

Try to push the array into the stacks. If each is full when it's tested, the array will be dropped.

Try to get an array from the stacks. If each is empty when it's tested, null will be returned.

Provides a simple, bounded stack of arrays, protected by a lock.

The arrays in the stack.

Number of arrays stored in .

Timestamp set by Trim when it sees this as 0.

Wrapper for arrays stored in ThreadStatic buckets.

The stored array.

Environment.TickCount timestamp for when this array was observed by Trim.

Represents position in non-contiguous set of memory. Properties of this type should not be interpreted by anything but the type that created it.

Creates new

Returns object part of this

Returns integer part of this

Indicates whether the current is equal to another . equality does not guarantee that they point to the same location in

Indicates whether the current is equal to another . equality does not guarantee that they point to the same location in

Returns approximate reciprocal of the divisor: ceil(2**64 / divisor).

This should only be used on 64-bit.

Performs a mod operation using the multiplier pre-computed with .

This should only be used on 64-bit.

Schedules a callback roughly every gen 2 GC (you may see a Gen 0 an Gen 1 but only once) (We can fix this by capturing the Gen 2 count at startup and testing, but I mostly don't care)

Schedule 'callback' to be called in the next GC. If the callback returns true it is rescheduled for the next Gen 2 GC. Otherwise the callbacks stop.

Schedule 'callback' to be called in the next GC. If the callback returns true it is rescheduled for the next Gen 2 GC. Otherwise the callbacks stop. NOTE: This callback will be kept alive until either the callback function returns false, or the target object dies.

Adds a span of bytes to the hash code.

The span. This method does not guarantee that the result of adding a span of bytes will match the result of adding the same bytes individually.

Extensions to providing consistent access to APIs introduced after the type.

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Returns clamped to the inclusive range of and .

The value to be clamped. The lower bound of the result. The upper bound of the result. if ≤ ≤ . -or- if < . -or- if < .

Memory represents a contiguous region of arbitrary memory similar to . Unlike , it is not a byref-like type.

Creates a new memory over the entirety of the target array.

The target array. Returns default when is null. Thrown when is covariant and array's type is not exactly T[].

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the memory. The number of items in the memory. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new memory from a memory manager that provides specific method implementations beginning at 0 index and ending at 'end' index (exclusive).

The memory manager. The number of items in the memory. Thrown when the specified is negative. For internal infrastructure only

Creates a new memory from a memory manager that provides specific method implementations beginning at 'start' index and ending at 'end' index (exclusive).

The memory manager. The index at which to begin the memory. The number of items in the memory. Thrown when the specified or is negative. For internal infrastructure only

Defines an implicit conversion of an array to a

Defines an implicit conversion of a to a

Defines an implicit conversion of a to a

Returns an empty

The number of items in the memory.

Returns true if Length is 0.

For , returns a new instance of string that represents the characters pointed to by the memory. Otherwise, returns a with the name of the type and the number of elements.

Forms a slice out of the given memory, beginning at 'start'.

The index at which to begin this slice. Thrown when the specified index is not in range (<0 or >=Length).

Forms a slice out of the given memory, beginning at 'start', of given length

The index at which to begin this slice. The desired length for the slice (exclusive). Thrown when the specified or end index is not in range (<0 or >=Length).

Returns a span from the memory.

Copies the contents of the memory into the destination. If the source and destination overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. The Memory to copy items into. Thrown when the destination is shorter than the source.

Copies the contents of the memory into the destination. If the source and destination overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. If the destination is shorter than the source, this method return false and no data is written to the destination.

The span to copy items into.

Creates a handle for the memory. The GC will not move the memory until the returned is disposed, enabling taking and using the memory's address. An instance with nonprimitive (non-blittable) members cannot be pinned.

Copies the contents from the memory into a new array. This heap allocates, so should generally be avoided, however it is sometimes necessary to bridge the gap with APIs written in terms of arrays.

Determines whether the specified object is equal to the current object. Returns true if the object is Memory or ReadOnlyMemory and if both objects point to the same array and have the same length.

Returns true if the memory points to the same array and has the same length. Note that this does *not* check to see if the *contents* are equal.

Serves as the default hash function.

Extension methods for Span{T}, Memory{T}, and friends.

Extension methods for Span{T}, Memory{T}, and friends.

Removes all leading and trailing white-space characters from the span.

Removes all leading white-space characters from the span.

Removes all trailing white-space characters from the span.

Removes all leading and trailing occurrences of a specified character.

The source span from which the character is removed. The specified character to look for and remove.

Removes all leading occurrences of a specified character.

The source span from which the character is removed. The specified character to look for and remove.

Removes all trailing occurrences of a specified character.

The source span from which the character is removed. The specified character to look for and remove.

Removes all leading and trailing occurrences of a set of characters specified in a readonly span from the span.

The source span from which the characters are removed. The span which contains the set of characters to remove. If is empty, white-space characters are removed instead.

Removes all leading occurrences of a set of characters specified in a readonly span from the span.

The source span from which the characters are removed. The span which contains the set of characters to remove. If is empty, white-space characters are removed instead.

Removes all trailing occurrences of a set of characters specified in a readonly span from the span.

The source span from which the characters are removed. The span which contains the set of characters to remove. If is empty, white-space characters are removed instead.

Indicates whether the specified span contains only white-space characters.

Searches for the specified value and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The value to search for.

Searches for the specified sequence and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The sequence to search for.

Searches for the specified value and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The value to search for.

Searches for the specified sequence and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The sequence to search for.

Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).

Determines the relative order of the sequences being compared by comparing the elements using IComparable{T}.CompareTo(T).

Searches for the specified value and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The value to search for.

Searches for the specified sequence and returns the index of its first occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The sequence to search for.

Searches for the specified value and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The value to search for.

Searches for the specified sequence and returns the index of its last occurrence. If not found, returns -1. Values are compared using IEquatable{T}.Equals(T).

The span to search. The sequence to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for. One of the values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. The set of values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for. One of the values to search for.

Searches for the first index of any of the specified values similar to calling IndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. The set of values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for. One of the values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. The set of values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. One of the values to search for. One of the values to search for. One of the values to search for.

Searches for the last index of any of the specified values similar to calling LastIndexOf several times with the logical OR operator. If not found, returns -1.

The span to search. The set of values to search for.

Determines whether two sequences are equal by comparing the elements using IEquatable{T}.Equals(T).

Determines the relative order of the sequences being compared by comparing the elements using IComparable{T}.CompareTo(T).

Determines whether the specified sequence appears at the start of the span.

Determines whether the specified sequence appears at the start of the span.

Determines whether the specified sequence appears at the end of the span.

Determines whether the specified sequence appears at the end of the span.

Reverses the sequence of the elements in the entire span.

Creates a new span over the target array.

Creates a new Span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the Span. The number of items in the Span. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new span over the portion of the target array segment.

Creates a new Span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the Span. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=segment.Count).

Creates a new Span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the Span. The number of items in the Span. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=segment.Count).

Creates a new memory over the target array.

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the memory. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=array.Length).

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the memory. The number of items in the memory. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new memory over the portion of the target array.

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the memory. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=segment.Count).

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the memory. The number of items in the memory. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=segment.Count).

Copies the contents of the array into the span. If the source and destinations overlap, this method behaves as if the original values in a temporary location before the destination is overwritten. The array to copy items from. The span to copy items into. Thrown when the destination Span is shorter than the source array.

Copies the contents of the array into the memory. If the source and destinations overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. The array to copy items from. The memory to copy items into. Thrown when the destination is shorter than the source array.

Determines whether two sequences overlap in memory.

Determines whether two sequences overlap in memory and outputs the element offset.

Determines whether two sequences overlap in memory.

Determines whether two sequences overlap in memory and outputs the element offset.

Searches an entire sorted for a value using the specified generic interface.

The element type of the span. The sorted to search. The to use when comparing. The zero-based index of in the sorted , if is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . is .

Searches an entire sorted for a value using the specified generic type.

The element type of the span. The specific type of . The sorted to search. The to use when comparing. The zero-based index of in the sorted , if is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . is .

Searches an entire sorted for the specified using the specified generic type.

The element type of the span. The specific type of . The sorted to search. The object to locate. The value can be null for reference types. The to use when comparing. /// The zero-based index of in the sorted , if is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . is .

Searches an entire sorted for a value using the specified generic interface.

The element type of the span. The sorted to search. The to use when comparing. The zero-based index of in the sorted , if is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . is .

Searches an entire sorted for a value using the specified generic type.

The element type of the span. The specific type of . The sorted to search. The to use when comparing. The zero-based index of in the sorted , if is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . is .

Searches an entire sorted for the specified using the specified generic type.

The element type of the span. The specific type of . The sorted to search. The object to locate. The value can be null for reference types. The to use when comparing. /// The zero-based index of in the sorted , if is found; otherwise, a negative number that is the bitwise complement of the index of the next element that is larger than or, if there is no larger element, the bitwise complement of . is .

Creates a new span over the portion of the target array.

Returns a value indicating whether the specified occurs within the . The source span. The value to seek within the source span. One of the enumeration values that determines how the and are compared.

Determines whether this and the specified span have the same characters when compared using the specified option. The source span. The value to compare with the source span. One of the enumeration values that determines how the and are compared.

Compares the specified and using the specified , and returns an integer that indicates their relative position in the sort order. The source span. The value to compare with the source span. One of the enumeration values that determines how the and are compared.

Reports the zero-based index of the first occurrence of the specified in the current . The source span. The value to seek within the source span. One of the enumeration values that determines how the and are compared.

Copies the characters from the source span into the destination, converting each character to lowercase, using the casing rules of the specified culture.

The source span. The destination span which contains the transformed characters. An object that supplies culture-specific casing rules. If the source and destinations overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. Thrown when is null.

Copies the characters from the source span into the destination, converting each character to lowercase, using the casing rules of the invariant culture.

The source span. The destination span which contains the transformed characters. If the source and destinations overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten.

Copies the characters from the source span into the destination, converting each character to uppercase, using the casing rules of the specified culture.

The source span. The destination span which contains the transformed characters. An object that supplies culture-specific casing rules. If the source and destinations overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. Thrown when is null.

Copies the characters from the source span into the destination, converting each character to uppercase using the casing rules of the invariant culture.

The source span. The destination span which contains the transformed characters. If the source and destinations overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten.

Determines whether the end of the matches the specified when compared using the specified option.

The source span. The sequence to compare to the end of the source span. One of the enumeration values that determines how the and are compared.

Determines whether the beginning of the matches the specified when compared using the specified option.

The source span. The sequence to compare to the beginning of the source span. One of the enumeration values that determines how the and are compared.

Creates a new readonly span over the portion of the target string.

The target string. Returns default when is null.

Creates a new readonly span over the portion of the target string.

The target string. The index at which to begin this slice. Returns default when is null. Thrown when the specified index is not in range (<0 or >text.Length).

Creates a new readonly span over the portion of the target string.

The target string. The index at which to begin this slice. The desired length for the slice (exclusive). Returns default when is null. Thrown when the specified index or is not in range.

Creates a new over the portion of the target string.

The target string. Returns default when is null.

Creates a new over the portion of the target string.

The target string. The index at which to begin this slice. Returns default when is null. Thrown when the specified index is not in range (<0 or >text.Length).

Creates a new over the portion of the target string.

The target string. The index at which to begin this slice. The desired length for the slice (exclusive). Returns default when is null. Thrown when the specified index or is not in range.

Represents a contiguous region of memory, similar to . Unlike , it is not a byref-like type.

Creates a new memory over the entirety of the target array.

The target array. Returns default when is null. Thrown when is covariant and array's type is not exactly T[].

Creates a new memory over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the memory. The number of items in the memory. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new memory over the existing object, start, and length. No validation is performed.

The target object. The index at which to begin the memory. The number of items in the memory.

Defines an implicit conversion of an array to a

Defines an implicit conversion of a to a

Returns an empty

The number of items in the memory.

Returns true if Length is 0.

For , returns a new instance of string that represents the characters pointed to by the memory. Otherwise, returns a with the name of the type and the number of elements.

Forms a slice out of the given memory, beginning at 'start'.

The index at which to begin this slice. Thrown when the specified index is not in range (<0 or >=Length).

Forms a slice out of the given memory, beginning at 'start', of given length

The index at which to begin this slice. The desired length for the slice (exclusive). Thrown when the specified or end index is not in range (<0 or >=Length).

Returns a span from the memory.

Copies the contents of the read-only memory into the destination. If the source and destination overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. The Memory to copy items into. Thrown when the destination is shorter than the source.

Copies the contents of the readonly-only memory into the destination. If the source and destination overlap, this method behaves as if the original values are in a temporary location before the destination is overwritten. If the destination is shorter than the source, this method return false and no data is written to the destination.

The span to copy items into.

Creates a handle for the memory. The GC will not move the memory until the returned is disposed, enabling taking and using the memory's address. An instance with nonprimitive (non-blittable) members cannot be pinned.

Copies the contents from the memory into a new array. This heap allocates, so should generally be avoided, however it is sometimes necessary to bridge the gap with APIs written in terms of arrays.

Determines whether the specified object is equal to the current object.

Returns true if the memory points to the same array and has the same length. Note that this does *not* check to see if the *contents* are equal.

Returns the hash code for this

Gets the state of the memory as individual fields.

The offset. The count. The object.

ReadOnlySpan represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed or native memory, or to memory allocated on the stack. It is type- and memory-safe.

ReadOnlySpan represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed or native memory, or to memory allocated on the stack. It is type- and memory-safe.

The number of items in the read-only span.

Returns true if Length is 0.

Returns false if left and right point at the same memory and have the same length. Note that this does *not* check to see if the *contents* are equal.

This method is not supported as spans cannot be boxed. To compare two spans, use operator==. Always thrown by this method.

This method is not supported as spans cannot be boxed. Always thrown by this method.

Defines an implicit conversion of an array to a

Defines an implicit conversion of a to a

Returns a 0-length read-only span whose base is the null pointer.

Gets an enumerator for this span.

Enumerates the elements of a .

The span being enumerated.

The next index to yield.

Initialize the enumerator.

The span to enumerate.

Advances the enumerator to the next element of the span.

Gets the element at the current position of the enumerator.

Creates a new read-only span over the entirety of the target array.

The target array. Returns default when is null. Thrown when is covariant and array's type is not exactly T[].

Creates a new read-only span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the read-only span. The number of items in the read-only span. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new read-only span over the target unmanaged buffer. Clearly this is quite dangerous, because we are creating arbitrarily typed T's out of a void*-typed block of memory. And the length is not checked. But if this creation is correct, then all subsequent uses are correct.

An unmanaged pointer to memory. The number of elements the memory contains. Thrown when is reference type or contains pointers and hence cannot be stored in unmanaged memory. Thrown when the specified is negative.

Returns the specified element of the read-only span.

Thrown when index less than 0 or index greater than or equal to Length

Returns a reference to the 0th element of the Span. If the Span is empty, returns null reference. It can be used for pinning and is required to support the use of span within a fixed statement.

Copies the contents of this read-only span into destination span. If the source and destinations overlap, this method behaves as if the original values in a temporary location before the destination is overwritten.

The span to copy items into. Thrown when the destination Span is shorter than the source Span.

Copies the contents of this read-only span into destination span. If the source and destinations overlap, this method behaves as if the original values in a temporary location before the destination is overwritten.

If the destination span is shorter than the source span, this method return false and no data is written to the destination. The span to copy items into.

Returns true if left and right point at the same memory and have the same length. Note that this does *not* check to see if the *contents* are equal.

For , returns a new instance of string that represents the characters pointed to by the span. Otherwise, returns a with the name of the type and the number of elements.

Forms a slice out of the given read-only span, beginning at 'start'.

The index at which to begin this slice. Thrown when the specified index is not in range (<0 or >=Length).

Forms a slice out of the given read-only span, beginning at 'start', of given length

The index at which to begin this slice. The desired length for the slice (exclusive). Thrown when the specified or end index is not in range (<0 or >=Length).

Copies the contents of this read-only span into a new array. This heap allocates, so should generally be avoided, however it is sometimes necessary to bridge the gap with APIs written in terms of arrays.

Returns a reference to the 0th element of the Span. If the Span is empty, returns a reference to the location where the 0th element would have been stored. Such a reference can be used for pinning but must never be dereferenced.

Span represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed or native memory, or to memory allocated on the stack. It is type- and memory-safe.

Span represents a contiguous region of arbitrary memory. Unlike arrays, it can point to either managed or native memory, or to memory allocated on the stack. It is type- and memory-safe.

The number of items in the span.

Returns true if Length is 0.

Returns false if left and right point at the same memory and have the same length. Note that this does *not* check to see if the *contents* are equal.

This method is not supported as spans cannot be boxed. To compare two spans, use operator==. Always thrown by this method.

This method is not supported as spans cannot be boxed. Always thrown by this method.

Defines an implicit conversion of an array to a

Defines an implicit conversion of a to a

Returns an empty

Gets an enumerator for this span.

Enumerates the elements of a .

The span being enumerated.

The next index to yield.

Initialize the enumerator.

The span to enumerate.

Advances the enumerator to the next element of the span.

Gets the element at the current position of the enumerator.

Creates a new span over the entirety of the target array.

The target array. Returns default when is null. Thrown when is covariant and array's type is not exactly T[].

Creates a new span over the portion of the target array beginning at 'start' index and ending at 'end' index (exclusive).

The target array. The index at which to begin the span. The number of items in the span. Returns default when is null. Thrown when is covariant and array's type is not exactly T[]. Thrown when the specified or end index is not in the range (<0 or >=Length).

Creates a new span over the target unmanaged buffer. Clearly this is quite dangerous, because we are creating arbitrarily typed T's out of a void*-typed block of memory. And the length is not checked. But if this creation is correct, then all subsequent uses are correct.

An unmanaged pointer to memory. The number of elements the memory contains. Thrown when is reference type or contains pointers and hence cannot be stored in unmanaged memory. Thrown when the specified is negative.

Returns a reference to specified element of the Span.

Thrown when index less than 0 or index greater than or equal to Length

Returns a reference to the 0th element of the Span. If the Span is empty, returns null reference. It can be used for pinning and is required to support the use of span within a fixed statement.

Clears the contents of this span.

Fills the contents of this span with the given value.

Copies the contents of this span into destination span. If the source and destinations overlap, this method behaves as if the original values in a temporary location before the destination is overwritten. The span to copy items into. Thrown when the destination Span is shorter than the source Span.

Copies the contents of this span into destination span. If the source and destinations overlap, this method behaves as if the original values in a temporary location before the destination is overwritten. If the destination span is shorter than the source span, this method return false and no data is written to the destination.

The span to copy items into.

Returns true if left and right point at the same memory and have the same length. Note that this does *not* check to see if the *contents* are equal.

Defines an implicit conversion of a to a

For , returns a new instance of string that represents the characters pointed to by the span. Otherwise, returns a with the name of the type and the number of elements.

Forms a slice out of the given span, beginning at 'start'.

The index at which to begin this slice. Thrown when the specified index is not in range (<0 or >=Length).

Forms a slice out of the given span, beginning at 'start', of given length

The index at which to begin this slice. The desired length for the slice (exclusive). Thrown when the specified or end index is not in range (<0 or >=Length).

Copies the contents of this span into a new array. This heap allocates, so should generally be avoided, however it is sometimes necessary to bridge the gap with APIs written in terms of arrays.

Returns a reference to the 0th element of the Span. If the Span is empty, returns a reference to the location where the 0th element would have been stored. Such a reference can be used for pinning but must never be dereferenced.

Implements the copy functionality used by Span and ReadOnlySpan. NOTE: Fast span implements TryCopyTo in corelib and therefore this implementation is only used by portable span. The code must live in code that only compiles for portable span which means either each individual span implementation of this shared code file. Other shared SpanHelper.X.cs files are compiled for both portable and fast span implementations.

Computes "start + index * sizeof(T)", using the unsigned IntPtr-sized multiplication for 32 and 64 bits. Assumptions: Start and index are non-negative, and already pre-validated to be within the valid range of their containing Span. If the byte length (Span.Length * sizeof(T)) does an unsigned overflow (i.e. the buffer wraps or is too big to fit within the address space), the behavior is undefined.

Determine if a type is eligible for storage in unmanaged memory. Portable equivalent of RuntimeHelpers.IsReferenceOrContainsReferences{T}()

Utility methods for intrinsic bit-twiddling operations. The methods use hardware intrinsics when available on the underlying platform, otherwise they use optimized software fallbacks.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since Log(0) is undefined. Does not directly use any hardware intrinsics, nor does it incur branching.

The value.

Returns the integer (ceiling) log of the specified value, base 2.

The value.

Returns the integer (ceiling) log of the specified value, base 2.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Count the number of trailing zero bits in an integer value. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in an integer value. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32. The rotated value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..63] is treated as congruent mod 64. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..63] is treated as congruent mod 64. The rotated value.

Reset the lowest significant bit in the given value

Reset specific bit in the given value

Extensions to providing consistent access to APIs introduced after the type.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Evaluate whether a given integral value is a power of 2.

The value.

Round the given integral value up to a power of 2.

The value. The smallest power of 2 which is greater than or equal to . If is 0 or the result overflows, returns 0.

Round the given integral value up to a power of 2.

The value. The smallest power of 2 which is greater than or equal to . If is 0 or the result overflows, returns 0.

Round the given integral value up to a power of 2.

The value. The smallest power of 2 which is greater than or equal to . If is 0 or the result overflows, returns 0.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Count the number of leading zero bits in a mask. Similar in behavior to the x86 instruction LZCNT.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the integer (floor) log of the specified value, base 2. Note that by convention, input value 0 returns 0 since log(0) is undefined.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Returns the population count (number of bits set) of a mask. Similar in behavior to the x86 instruction POPCNT.

The value.

Count the number of trailing zero bits in an integer value. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in an integer value. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Count the number of trailing zero bits in a mask. Similar in behavior to the x86 instruction TZCNT.

The value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32. The rotated value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..63] is treated as congruent mod 64. The rotated value.

Rotates the specified value left by the specified number of bits. Similar in behavior to the x86 instruction ROL.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32 on a 32-bit process, and any value outside the range [0..63] is treated as congruent mod 64 on a 64-bit process. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..63] is treated as congruent mod 64. The rotated value.

Rotates the specified value right by the specified number of bits. Similar in behavior to the x86 instruction ROR.

The value to rotate. The number of bits to rotate by. Any value outside the range [0..31] is treated as congruent mod 32 on a 32-bit process, and any value outside the range [0..63] is treated as congruent mod 64 on a 64-bit process. The rotated value.

Extensions to providing consistent access to APIs introduced after the type.

Extensions to providing consistent access to APIs introduced after the type.