Permalink
Fetching contributors…
Cannot retrieve contributors at this time
13993 lines (11344 sloc) 746 KB
<Type Name="OpCodes" FullName="System.Reflection.Emit.OpCodes">
<TypeSignature Language="C#" Value="public class OpCodes" />
<TypeSignature Language="ILAsm" Value=".class public auto ansi beforefieldinit OpCodes extends System.Object" />
<TypeSignature Language="DocId" Value="T:System.Reflection.Emit.OpCodes" />
<TypeSignature Language="VB.NET" Value="Public Class OpCodes" />
<TypeSignature Language="C++ CLI" Value="public ref class OpCodes" />
<TypeSignature Language="F#" Value="type OpCodes = class" />
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Base>
<BaseTypeName>System.Object</BaseTypeName>
</Base>
<Interfaces />
<Attributes>
<Attribute FrameworkAlternate="netframework-2.0;netframework-3.0;netframework-3.5;netframework-4.0;netframework-4.5;netframework-4.5.1;netframework-4.5.2;netframework-4.6;netframework-4.6.1;netframework-4.6.2;netframework-4.7;netframework-4.7.1;netframework-4.7.2;xamarinandroid-7.1;xamarinios-10.8;xamarinmac-3.0">
<AttributeName>System.Runtime.InteropServices.ComVisible(true)</AttributeName>
</Attribute>
</Attributes>
<Docs>
<summary>Provides field representations of the Microsoft Intermediate Language (MSIL) instructions for emission by the <see cref="T:System.Reflection.Emit.ILGenerator" /> class members (such as <see cref="M:System.Reflection.Emit.ILGenerator.Emit(System.Reflection.Emit.OpCode)" />).</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
For a detailed description of the member opcodes, see the Common Language Infrastructure (CLI) documentation, especially "Partition III: CIL Instruction Set" and "Partition II: Metadata Definition and Semantics". The documentation is available online; see [ECMA C# and Common Language Infrastructure Standards](http://go.microsoft.com/fwlink/?LinkID=99212) on MSDN and [Standard ECMA-335 - Common Language Infrastructure (CLI)](http://go.microsoft.com/fwlink/?LinkID=65552) on the Ecma International Web site.
## Examples
The following example demonstrates the construction of a dynamic method using <xref:System.Reflection.Emit.ILGenerator> to emit `OpCodes` into a <xref:System.Reflection.Emit.MethodBuilder>.
[!code-cpp[System.Reflection.Emit.ILGenerator.OpCodes Example#1](~/samples/snippets/cpp/VS_Snippets_CLR_System/system.Reflection.Emit.ILGenerator.OpCodes Example/CPP/source.cpp#1)]
[!code-csharp[System.Reflection.Emit.ILGenerator.OpCodes Example#1](~/samples/snippets/csharp/VS_Snippets_CLR_System/system.Reflection.Emit.ILGenerator.OpCodes Example/CS/source.cs#1)]
[!code-vb[System.Reflection.Emit.ILGenerator.OpCodes Example#1](~/samples/snippets/visualbasic/VS_Snippets_CLR_System/system.Reflection.Emit.ILGenerator.OpCodes Example/VB/source.vb#1)]
]]></format>
</remarks>
</Docs>
<Members>
<Member MemberName="Add">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Add;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Add" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Add" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Add As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Add;" />
<MemberSignature Language="F#" Value=" staticval mutable Add : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Add" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Adds two values and pushes the result onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|58|add|Adds two numeric values, returning a new numeric value.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; `value1` is added to `value2`.
4. The result is pushed onto the stack.
Overflow is not detected for integer operations (for proper overflow handling, see <xref:System.Reflection.Emit.OpCodes.Add_Ovf>).
Integer addition wraps, rather than saturates. For example, assuming 8-bit integers where `value1` is set to 255 and `value2` is set to 1, the wrapped result is 0 rather than 256.
Floating-point overflow returns `+inf` (`PositiveInfinity`) or `-inf` (`NegativeInfinity`).
The acceptable operand types and their corresponding result data type are listed in the table below. If there is no entry for a particular type combination (for example, `int32` and `float`; `int32` and `int64`), it is an invalid Microsoft Intermediate Language (MSIL) and generates an error.
|operand|value1 type|value2 type|result type|
|-------------|-----------------|-----------------|-----------------|
|add|`int32`|`int32`|`int32`|
|add|`int32`|`native int`|`native int`|
|add|`int32`|`&`|`&`|
|add|`int32`|`*`|`*`|
|add|`int64`|`int64`|`int64`|
|add|`native int`|`int32`|`native int`|
|add|`native int`|`native int`|`native int`|
|add|`native int`|`&`|`&`|
|add|`native int`|`*`|`*`|
|add|`F`|`F`|`F`|
|add|`&`|`int32`|`&`|
|add|`&`|`native int`|`&`|
|add|`*`|`int32`|`*`|
|add|`*`|`native int`|`*`|
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `add` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Add_Ovf">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Add_Ovf;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Add_Ovf" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Add_Ovf" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Add_Ovf As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Add_Ovf;" />
<MemberSignature Language="F#" Value=" staticval mutable Add_Ovf : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Add_Ovf" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Adds two integers, performs an overflow check, and pushes the result onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|D6|add.ovf|Adds two signed integer values with an overflow check.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; `value1` is added to `value2` with a check for overflow.
4. The result is pushed onto the stack.
<xref:System.OverflowException> is thrown if the result is not represented in the result type.
You can perform this operation on signed integers. For floating-point values, use <xref:System.Reflection.Emit.OpCodes.Add>.
The acceptable operand types and their corresponding result data type are listed in the table below. If there is no entry for a particular type combination (for example, `int32` and `float`; `int32` and `int64`), it is an invalid Microsoft Intermediate Language (MSIL) instruction and generates an error.
|operand|value1 type|value2 type|result type|
|-------------|-----------------|-----------------|-----------------|
|add|`int32`|`int32`|`int32`|
|add|`int32`|`native int`|`native int`|
|add|`int32`|`&`|`&`|
|add|`int32`|`*`|`*`|
|add|`int64`|`int64`|`int64`|
|add|`native int`|`int32`|`native int`|
|add|`native int`|`native int`|`native int`|
|add|`native int`|`&`|`&`|
|add|`native int`|`*`|`*`|
|add|`F`|`F`|`F`|
|add|`&`|`int32`|`&`|
|add|`&`|`native int`|`&`|
|add|`*`|`int32`|`*`|
|add|`*`|`native int`|`*`|
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `add.ovf` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Add_Ovf_Un">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Add_Ovf_Un;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Add_Ovf_Un" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Add_Ovf_Un" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Add_Ovf_Un As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Add_Ovf_Un;" />
<MemberSignature Language="F#" Value=" staticval mutable Add_Ovf_Un : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Add_Ovf_Un" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Adds two unsigned integer values, performs an overflow check, and pushes the result onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|D7|add.ovf.un|Adds two unsigned integer values with an overflow check.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; `value1` is added to `value2` with a check for overflow.
4. The result is pushed onto the stack.
<xref:System.OverflowException> is thrown if the result is not represented in the result type.
You can perform this operation on signed integers. For floating-point values, use <xref:System.Reflection.Emit.OpCodes.Add>.
The acceptable operand types and their corresponding result data type are listed in the table below. If there is no entry for a particular type combination (for example, `int32` and `float`; `int32` and `int64`), it is an invalid Microsoft Intermediate Language (MSIL) instruction and generates an error.
|operand|value1 type|value2 type|result type|
|-------------|-----------------|-----------------|-----------------|
|add|`int32`|`int32`|`int32`|
|add|`int32`|`native int`|`native int`|
|add|`int32`|`&`|`&`|
|add|`int32`|`*`|`*`|
|add|`int64`|`int64`|`int64`|
|add|`native int`|`int32`|`native int`|
|add|`native int`|`native int`|`native int`|
|add|`native int`|`&`|`&`|
|add|`native int`|`*`|`*`|
|add|`F`|`F`|`F`|
|add|`&`|`int32`|`&`|
|add|`&`|`native int`|`&`|
|add|`*`|`int32`|`*`|
|add|`*`|`native int`|`*`|
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `add.ovf.un` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="And">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode And;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode And" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.And" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly And As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode And;" />
<MemberSignature Language="F#" Value=" staticval mutable And : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.And" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Computes the bitwise AND of two values and pushes the result onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Instruction|Description|
|------------|-----------------|-----------------|
|5F|and|Determines the bitwise AND of two integer values.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value1` and `value2` are popped from the stack; the bitwise AND of the two values is computed.
4. The result is pushed onto the stack.
The `and` instruction computes the bitwise AND of the top two values on the stack and leaves the result on the stack.
`And` is an integer-specific operation.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `and` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Arglist">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Arglist;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Arglist" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Arglist" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Arglist As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Arglist;" />
<MemberSignature Language="F#" Value=" staticval mutable Arglist : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Arglist" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Returns an unmanaged pointer to the argument list of the current method.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|FE 00|arglist|Returns an argument list handle for the current method.|
No evaluation stack behaviors are performed by this operation.
The `arglist` instruction returns an opaque handle (an unmanaged pointer, of type `native int`) that represents the argument list of the current method. This handle is valid only during the lifetime of the current method. You can, however, pass the handle to other methods as long as the current method is on the thread of control. You can only execute the `arglist` instruction within a method that takes a variable number of arguments.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `arglist` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Beq">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Beq;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Beq" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Beq" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Beq As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Beq;" />
<MemberSignature Language="F#" Value=" staticval mutable Beq : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Beq" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if two values are equal.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|3B < `int32` >|beq `target`|Branch to the target instruction at offset `target` if the two values are equal.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is equal to `value2`, the branch operation is performed.
The `beq` instruction transfers control to the specified target instruction if `value1` is equal to `value2`. The effect is the same as performing a `ceq` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
The acceptable operand types are encapsulated below:
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes.
Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction (such transfers are severely restricted and must use the <xref:System.Reflection.Emit.OpCodes.Leave> instruction instead).
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `beq` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Beq_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Beq_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Beq_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Beq_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Beq_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Beq_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Beq_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Beq_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if two values are equal.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|2E < `int8` >|beq.s `target`|Branch to the target instruction at offset `target` if equal, short form|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is equal to `value2`, the branch operation is performed.
The `beq.s` instruction transfers control to the specified target instruction if `value1` is equal to `value2`. The effect is the same as performing a `ceq` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
The acceptable operand types are encapsulated below:
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes.
Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction (such transfers are severely restricted and must use the <xref:System.Reflection.Emit.OpCodes.Leave> instruction instead).
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `beq.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bge">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bge;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bge" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bge" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bge As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bge;" />
<MemberSignature Language="F#" Value=" staticval mutable Bge : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bge" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if the first value is greater than or equal to the second value.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|3C `<int32>`|bge `target`|Branch to the target instruction at the specified offset if the first value is greater than or equal to the second value.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is greater than or equal to `value2`, the branch operation is performed.
The `bge` instruction transfers control to the specified target instruction if `value1` is greater than or equal to `value2`. The effect is identical to performing a `clt.un` instruction followed by a `brfalse` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bge` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bge_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bge_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bge_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bge_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bge_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bge_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Bge_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bge_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if the first value is greater than or equal to the second value.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|2F `<int8>`|bge.s `target`|Branch to the target instruction at the specified offset if the first value is greater than or equal to the second value, short form.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is greater than or equal to `value2`, the branch operation is performed.
The `bge.s` instruction transfers control to the specified target instruction if `value1` is greater than or equal to `value2`. The effect is identical to performing a `clt.un` instruction followed by a `brfalse` branch to the specific target instruction. The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bge.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bge_Un">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bge_Un;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bge_Un" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bge_Un" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bge_Un As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bge_Un;" />
<MemberSignature Language="F#" Value=" staticval mutable Bge_Un : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bge_Un" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if the first value is greater than the second value, when comparing unsigned integer values or unordered float values.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|41 `<int32>`|bge.un `target`|Branch to the target instruction at the specified offset if the first value is greater than or equal to the second value (unsigned values).|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is greater than or equal to `value2`, the branch operation is performed.
The `bge.un` instruction transfers control to the specified target instruction if `value1` is greater than or equal to `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `clt` instruction followed by a `brfalse` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bge.un` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bge_Un_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bge_Un_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bge_Un_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bge_Un_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bge_Un_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bge_Un_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Bge_Un_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bge_Un_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if the first value is greater than the second value, when comparing unsigned integer values or unordered float values.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|34 < `int8` >|bge.un.s `target`|Branch to the target instruction at the specified offset if the first value is greater than or equal to the second value (unsigned values), short form.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is greater than or equal to `value2`, the branch operation is performed.
The `bge.un.s` instruction transfers control to the specified target instruction if `value1` is greater than or equal to `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `clt` instruction followed by a `brfalse` branch to the specific target instruction. The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bge.un.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bgt">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bgt;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bgt" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bgt" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bgt As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bgt;" />
<MemberSignature Language="F#" Value=" staticval mutable Bgt : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bgt" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if the first value is greater than the second value.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|3D < `int32` >|bgt `target`|Branch to the target instruction at the specified offset if the first value is greater than the second value.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is greater than `value2`, the branch operation is performed.
The `bgt` instruction transfers control to the specified target instruction if `value1` is greater than `value2`. The effect is identical to performing a `cgt` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bgt` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bgt_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bgt_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bgt_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bgt_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bgt_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bgt_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Bgt_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bgt_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if the first value is greater than the second value.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|30 < `int8` >|bgt.s `target`|Branch to the target instruction at the specified offset if the first value is greater than the second value, short form.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is greater than `value2`, the branch operation is performed.
The `bgt.s` instruction transfers control to the specified target instruction if `value1` is greater than `value2`. The effect is identical to performing a `cgt` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bgt.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bgt_Un">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bgt_Un;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bgt_Un" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bgt_Un" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bgt_Un As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bgt_Un;" />
<MemberSignature Language="F#" Value=" staticval mutable Bgt_Un : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bgt_Un" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if the first value is greater than the second value, when comparing unsigned integer values or unordered float values.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|42 < `int32` >|bgt.un `target`|Branch to the target instruction at the specified offset if the first value is greater than the second value (unsigned values).|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is greater than `value2`, the branch operation is performed.
The `bgt.un` instruction transfers control to the specified target instruction if `value1` is greater than `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `cgt.un` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bgt.un` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bgt_Un_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bgt_Un_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bgt_Un_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bgt_Un_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bgt_Un_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bgt_Un_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Bgt_Un_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bgt_Un_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if the first value is greater than the second value, when comparing unsigned integer values or unordered float values.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|35 < `int8` >|bgt.un.s `target`|Branch to the target instruction at the specified offset if the first value is greater than the second value (unsigned values), short form.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is greater than `value2`, the branch operation is performed.
The `bgt.un.s` instruction transfers control to the specified target instruction if `value1` is greater than `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `cgt.un` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bgt.un.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Ble">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Ble;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Ble" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Ble" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Ble As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Ble;" />
<MemberSignature Language="F#" Value=" staticval mutable Ble : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Ble" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if the first value is less than or equal to the second value.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|3E `<int32>`|ble `target`|Branch to the target instruction at the specified offset if the first value is less than or equal to the second value.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is less than or equal to `value2`, the branch operation is performed.
The `ble` instruction transfers control to the specified target instruction if `value1` is less than or equal to `value2`. The effect is identical to performing a `cgt` instruction (`cgt.un` for floats) followed by a `brfalse` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `ble` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Ble_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Ble_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Ble_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Ble_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Ble_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Ble_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Ble_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Ble_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if the first value is less than or equal to the second value.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|31 `<int8>`|ble.s `target`|Branch to the target instruction at the specified offset if the first value is less than or equal to the second value, short form.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is less than or equal to `value2`, the branch operation is performed.
The `ble.s` instruction transfers control to the specified target instruction if `value1` is less than or equal to `value2`. The effect is identical to performing a `cgt` instruction (`cgt.un` for floats) instruction followed by a`brfalse` branch to the specific target instruction. The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `ble.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Ble_Un">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Ble_Un;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Ble_Un" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Ble_Un" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Ble_Un As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Ble_Un;" />
<MemberSignature Language="F#" Value=" staticval mutable Ble_Un : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Ble_Un" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if the first value is less than or equal to the second value, when comparing unsigned integer values or unordered float values.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|43 `<int32>`|ble.un `target`|Branch to the target instruction at the specified offset if the first value is less than or equal to the second value (unsigned values).|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is less than or equal to `value2`, the branch operation is performed.
The `ble.un` instruction transfers control to the specified target instruction if `value1` is less than or equal to `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `cgt.un` instruction (`cgt` for floats) followed by a `brfalse` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `ble.un` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Ble_Un_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Ble_Un_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Ble_Un_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Ble_Un_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Ble_Un_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Ble_Un_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Ble_Un_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Ble_Un_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if the first value is less than or equal to the second value, when comparing unsigned integer values or unordered float values.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|36 `<int8>`|ble.un.s `target`|Branch to the target instruction at the specified offset if the first value is less than or equal to the second value (unsigned values), short form.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is less than or equal to `value2`, the branch operation is performed.
The `ble.un.s` instruction transfers control to the specified target instruction if `value1` is less than or equal to `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `cgt.un` instruction (`cgt` for floats) followed by a `brfalse` branch to the specific target instruction. The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `ble.un.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Blt">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Blt;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Blt" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Blt" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Blt As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Blt;" />
<MemberSignature Language="F#" Value=" staticval mutable Blt : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Blt" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if the first value is less than the second value.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|3F < `int32` >|blt `target`|Branch to the target instruction at the specified offset if the first value is less than the second value.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is less than `value2`, the branch operation is performed.
The `blt` instruction transfers control to the specified target instruction if `value1` is less than or equal to `value2`. The effect is identical to performing a `clt` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `blt` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Blt_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Blt_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Blt_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Blt_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Blt_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Blt_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Blt_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Blt_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if the first value is less than the second value.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|32 < `int8` >|blt.s `target`|Branch to the target instruction at the specified offset if the first value is less than the second value, short form.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is less than `value2`, the branch operation is performed.
The `blt.s` instruction transfers control to the specified target instruction if `value1` is less than `value2`. The effect is identical to performing a `clt` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `blt.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Blt_Un">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Blt_Un;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Blt_Un" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Blt_Un" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Blt_Un As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Blt_Un;" />
<MemberSignature Language="F#" Value=" staticval mutable Blt_Un : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Blt_Un" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if the first value is less than the second value, when comparing unsigned integer values or unordered float values.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|44 < `int32` >|blt.un `target`|Branch to the target instruction at the specified offset if the first value is less than the second value (unsigned values).|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is less than `value2`, the branch operation is performed.
The `blt.un` instruction transfers control to the specified target instruction if `value1` is less than `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `clt.un` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `blt.un` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Blt_Un_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Blt_Un_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Blt_Un_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Blt_Un_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Blt_Un_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Blt_Un_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Blt_Un_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Blt_Un_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if the first value is less than the second value, when comparing unsigned integer values or unordered float values.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|37 < `int8` >|blt.un.s `target`|Branch to the target instruction at the specified offset if the first value is less than the second value (unsigned values), short form.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is less than `value2`, the branch operation is performed.
The `blt.un` instruction transfers control to the specified target instruction if `value1` is less than `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `clt.un` instruction followed by a `brtrue` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `blt.un.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bne_Un">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bne_Un;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bne_Un" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bne_Un" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bne_Un As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bne_Un;" />
<MemberSignature Language="F#" Value=" staticval mutable Bne_Un : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bne_Un" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction when two unsigned integer values or unordered float values are not equal.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|40 < `int32` >|bne.un `target`|Branch to the target instruction at the specified offset if two unsigned integer values are not equal (unsigned values).|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is not equal to `value2`, the branch operation is performed.
The `bne.un` instruction transfers control to the specified target instruction if `value1` is not equal to `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `ceq` instruction followed by a `brfalse` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bne.un` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Bne_Un_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Bne_Un_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Bne_Un_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Bne_Un_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Bne_Un_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Bne_Un_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Bne_Un_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Bne_Un_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) when two unsigned integer values or unordered float values are not equal.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|33 < `int8` >|bne.un.s `target`|Branch to the target instruction at the specified offset if two unsigned integer values are not equal (unsigned values), short form.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; if `value1` is not equal to `value2`, the branch operation is performed.
The `bne.un` instruction transfers control to the specified target instruction if `value1` is not equal to `value2`, when compared using unsigned integer or unordered float values. The effect is identical to performing a `ceq` instruction followed by a `brfalse` branch to the specific target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `bne.un.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Box">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Box;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Box" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Box" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Box As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Box;" />
<MemberSignature Language="F#" Value=" staticval mutable Box : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Box" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Converts a value type to an object reference (type <see langword="O" />).</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|8C < `T` >|box `valTypeToken`|Convert a value type (of the type specified in `valTypeToken`) to a true object reference.|
The stack transitional behavior, in sequential order, is:
1. A value type is pushed onto the stack.
2. The value type is popped from the stack; the `box` operation is performed.
3. An object reference to the resulting "boxed" value type is pushed onto the stack.
A value type has two separate representations within the Common Language Infrastructure (CLI):
- A 'raw' form used when a value type is embedded within another object or on the stack.
- A 'boxed' form, where the data in the value type is wrapped (boxed) into an object so it can exist as an independent entity.
The `box` instruction converts the 'raw' (unboxed) value type into an object reference (type `O`). This is accomplished by creating a new object and copying the data from the value type into the newly allocated object. `valTypeToken` is a metadata token indicating the type of the value type on the stack.
<xref:System.OutOfMemoryException> is thrown if there is insufficient memory to satisfy the request.
<xref:System.TypeLoadException> is thrown if the class cannot be found. This is typically detected when Microsoft Intermediate Language (MSIL) is converted to native code, rather than at runtime.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `box` opcode:
- ILGenerator.Emit(OpCode, Type)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Br">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Br;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Br" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Br" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Br As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Br;" />
<MemberSignature Language="F#" Value=" staticval mutable Br : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Br" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Unconditionally transfers control to a target instruction.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|38 < `int32` >|br `target`|Branches to a target instruction at the specified offset.|
No evaluation stack behaviors are performed by this operation.
The `br` instruction unconditionally transfers control to a target instruction. The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `br` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Br_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Br_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Br_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Br_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Br_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Br_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Br_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Br_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Unconditionally transfers control to a target instruction (short form).</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|2B < `int8` >|br.s `target`|Branches to a target instruction at the specified offset, short form.|
No evaluation stack behaviors are performed by this operation.
The `br.s` instruction unconditionally transfers control to a target instruction. The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `br.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Break">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Break;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Break" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Break" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Break As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Break;" />
<MemberSignature Language="F#" Value=" staticval mutable Break : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Break" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Signals the Common Language Infrastructure (CLI) to inform the debugger that a break point has been tripped.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|01|break|inform a debugger that a breakpoint has been reached.|
No evaluation stack behaviors are performed by this operation.
The `break` instruction is for debugging support. It signals the CLI to inform the debugger that a break point has been tripped. It has no other effect on the interpreter state.
The `break` instruction has the smallest possible instruction size enabling code patching with a break point and generating minimal disturbance to the surrounding code.
The `break` instruction can trap to a debugger, do nothing, or raise a security exception. The exact behavior is implementation-defined.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `break` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Brfalse">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Brfalse;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Brfalse" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Brfalse" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Brfalse As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Brfalse;" />
<MemberSignature Language="F#" Value=" staticval mutable Brfalse : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Brfalse" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if <paramref name="value" /> is <see langword="false" />, a null reference (<see langword="Nothing" /> in Visual Basic), or zero.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|39 < `int32` >|brfalse `target`<br /><br /> brnull `target`<br /><br /> brzero `target`|Branches to a target instruction at the specified offset if `false`.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack by a previous operation.
2. `value` is popped from the stack; if `value` is `false`, branch to `target`.
The `brfalse` instruction (and its aliases `brnull` and `brzero`) transfers control to the specified target instruction if `value` (of type `int32`, `int64`, object reference `O`, managed pointer `&`, transient pointer `*`, `native int`) is zero (`false`). If `value` is non-zero (`true`) execution continues at the next instruction.
The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `brfalse` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Brfalse_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Brfalse_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Brfalse_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Brfalse_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Brfalse_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Brfalse_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Brfalse_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Brfalse_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if <paramref name="value" /> is <see langword="false" />, a null reference, or zero.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|2C <`int8` >|brfalse.s `target`<br /><br /> brnull.s `target`<br /><br /> brzero.s `target`|Branches to a target instruction at the specified offset if `false`, short form.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack by a previous operation.
2. `value` is popped from the stack; if `value` is `false`, branch to `target`.
The `brfalse.s` instruction (and its aliases `brnull` and `brzero`) transfers control to the specified target instruction if `value` (of type `int32`, `int64`, object reference `O`, managed pointer `&`, transient pointer `*`, `native int`) is zero (`false`). If `value` is non-zero (`true`) execution continues at the next instruction.
The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `brfalse.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Brtrue">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Brtrue;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Brtrue" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Brtrue" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Brtrue As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Brtrue;" />
<MemberSignature Language="F#" Value=" staticval mutable Brtrue : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Brtrue" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction if <paramref name="value" /> is <see langword="true" />, not null, or non-zero.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|3A < `int32` >|brtrue `target`<br /><br /> brinst `target`|Branch to a target instruction at the specified offset if non-zero (`true`).|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack by a previous operation.
2. `value` is popped from the stack; if `value` is `true`, branch to `target`.
The `brtrue` instruction transfers control to the specified target instruction if `value` (type `native int`) is nonzero (`true`). If `value` is zero (`false`) execution continues at the next instruction.
If `value` is an object reference (type `O`) then `brinst` (an alias for `brtrue`) transfers control if it represents an instance of an object (for example, if it is not the null object reference; see <xref:System.Reflection.Emit.OpCodes.Ldnull>).
The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `brtrue` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Brtrue_S">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Brtrue_S;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Brtrue_S" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Brtrue_S" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Brtrue_S As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Brtrue_S;" />
<MemberSignature Language="F#" Value=" staticval mutable Brtrue_S : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Brtrue_S" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Transfers control to a target instruction (short form) if <paramref name="value" /> is <see langword="true" />, not null, or non-zero.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|2D < `int8` >|brtrue.s `target`<br /><br /> brinst.s `target`|Branch to a target instruction at the specified offset if non-zero (`true`), short form.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack by a previous operation.
2. `value` is popped from the stack; if `value` is `true`, branch to `target`.
The `brtrue.s` instruction transfers control to the specified target instruction if `value` (type `native int`) is nonzero (`true`). If `value` is zero (`false`) execution continues at the next instruction.
If `value` is an object reference (type `O`) then `brinst` (an alias for `brtrue`) transfers control if it represents an instance of an object (for example, if it is not the null object reference; see <xref:System.Reflection.Emit.OpCodes.Ldnull>).
The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.
If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes. Control transfers into and out of `try`, `catch`, `filter`, and `finally` blocks cannot be performed by this instruction.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `brtrue.s` opcode:
- ILGenerator.Emit(OpCode, Label)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Call">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Call;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Call" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Call" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Call As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Call;" />
<MemberSignature Language="F#" Value=" staticval mutable Call : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Call" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Calls the method indicated by the passed method descriptor.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|28 < `T` >|call `methodDesc`|Call the method described by `methodDesc`.|
The stack transitional behavior, in sequential order, is:
1. Method arguments `arg1` through `argN` are pushed onto the stack.
2. Method arguments `arg1` through `argN` are popped from the stack; the method call is performed with these arguments and control is transferred to the method referred to by the method descriptor. When complete, a return value is generated by the callee method and sent to the caller.
3. The return value is pushed onto the stack.
The `call` instruction calls the method indicated by the method descriptor passed with the instruction. The method descriptor is a metadata token that indicates the method to call and the number, type, and order of the arguments that have been placed on the stack to be passed to that method as well as the calling convention to be used. The `call` instruction can be immediately preceded by a `tail` (<xref:System.Reflection.Emit.OpCodes.Tailcall>) prefix instruction to specify that the current method state should be released before transferring control. If the call transfers control to a method of higher trust than the origin method, the stack frame is not released. Instead, the execution continues silently as if the `tail` had not been supplied. The metadata token carries sufficient information to determine whether the call is to a static method, an instance method, a virtual method, or a global function. In all of these cases the destination address is determined entirely from the method descriptor (contrast this with the <xref:System.Reflection.Emit.OpCodes.Callvirt> instruction for calling virtual methods, where the destination address also depends upon the runtime type of the instance reference pushed before the <xref:System.Reflection.Emit.OpCodes.Callvirt>).
The arguments are placed on the stack in left-to-right order. That is, the first argument is computed and placed on the stack, then the second argument, then the third, until all necessary arguments are atop the stack in descending order. There are three important special cases:
1. Calls to an instance (or virtual) method must push that instance reference before any of the user-visible arguments. The instance reference must not be a null reference. The signature carried in the metadata does not contain an entry in the parameter list for the `this` pointer; instead, it uses a bit to indicate whether the method requires passing the `this` pointer.
2. It is valid to call a virtual method using `call` (rather than `callvirt`); this indicates that the method is to be resolved using the class specified by method rather than as specified dynamically from the object being invoked.
3. Note that a delegate's `Invoke` method can be called with either the `call` or `callvirt` instruction.
<xref:System.Security.SecurityException> may be thrown if system security does not grant the caller access to the called method. The security check may occur when the Microsoft Intermediate Language (MSIL) instructions are converted to native code rather than at run time.
> [!NOTE]
> When calling methods of System.Object on value types, consider using the `constrained` prefix with the `callvirt` instruction instead of emitting a `call` instruction. This removes the need to emit different IL depending on whether or not the value type overrides the method, avoiding a potential versioning problem. Consider using the `constrained` prefix when invoking interface methods on value types, since the value type method implementing the interface method can be changed using a `MethodImpl`. These issues are described in more detail in the <xref:System.Reflection.Emit.OpCodes.Constrained> opcode.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overloads can use the `call` opcode:
- ILGenerator.Emit(OpCode, MethodInfo)
- ILGenerator.EmitCall(OpCode, MethodInfo, Type[])
> [!NOTE]
> The <xref:System.Reflection.Emit.ILGenerator.EmitCall%2A> method is provided for `varargs` calls. Use the <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method for normal calls.
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Calli">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Calli;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Calli" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Calli" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Calli As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Calli;" />
<MemberSignature Language="F#" Value=" staticval mutable Calli : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Calli" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Calls the method indicated on the evaluation stack (as a pointer to an entry point) with arguments described by a calling convention.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|29 < `T` >|calli `callSiteDescr`|Calls the method pointed to with arguments described by the calling convention.|
The stack transitional behavior, in sequential order, is:
1. Method arguments `arg1` through `argN` are pushed onto the stack.
2. The method entry pointer is pushed onto the stack.
3. Method arguments `arg1` through `argN` and the method entry pointer are popped from the stack; the call to the method is performed. When complete, a return value is generated by the callee method and sent to the caller.
4. The return value is pushed onto the stack.
The `calli` instruction calls the method entry pointer with the arguments `arg1` through `argN`. The types of these arguments are described by the specific calling convention (`callSiteDesc`). The `calli` instruction may be immediately preceded by a `tail` prefix (<xref:System.Reflection.Emit.OpCodes.Tailcall>) to specify that the current method state should be released before transferring control. If the call would transfer control to a method of higher trust than the origin method the stack frame will not be released; instead, the execution will continue silently as if the `tail` had not been supplied.
The method entry pointer is assumed to be a specific pointer to native code (of the target machine) that can be legitimately called with the arguments described by the calling convention (a metadata token for a stand-alone signature). Such a pointer can be created using the <xref:System.Reflection.Emit.OpCodes.Ldftn> or <xref:System.Reflection.Emit.OpCodes.Ldvirtftn> instructions, or passed in from native code.
The calling convention is not checked dynamically, so code that uses a `calli` instruction does not work correctly if the destination does not actually use the specified calling convention.
The arguments are placed on the stack in left-to-right order. That is, the first argument is computed and placed on the stack, then the second argument, then the third, until all necessary arguments are atop the stack in descending order. The argument-building code sequence for an instance or virtual method must push that instance reference (which must not be a null reference) before any of the user-visible arguments.
<xref:System.Security.SecurityException> may be thrown if the system security does not grant the caller access to the called method. The security check can occur when the Microsoft Intermediate Language (MSIL) instructions are converted to native code rather than at runtime.
The following <xref:System.Reflection.Emit.ILGenerator.EmitCalli%2A> methods can be used to perform a `calli` instruction on the stack. Note that `calli` should be called through the below methods rather than using the <xref:System.Reflection.Emit.ILGenerator.Emit%2A> class to place the instruction directly on the stack.
- ILGenerator.EmitCalli(Opcode, CallingConventions, Type, Type[], Type[]) for calls using a managed calling convention.
- ILGenerator.EmitCalli(Opcode, CallingConvention, Type, Type[]) for calls using an unmanaged calling convention.
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Callvirt">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Callvirt;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Callvirt" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Callvirt" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Callvirt As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Callvirt;" />
<MemberSignature Language="F#" Value=" staticval mutable Callvirt : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Callvirt" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Calls a late-bound method on an object, pushing the return value onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|6F < `T` >|callvirt `method`|Calls a specific method associated with `obj`.|
The stack transitional behavior, in sequential order, is:
1. An object reference `obj` is pushed onto the stack.
2. Method arguments `arg1` through `argN` are pushed onto the stack.
3. Method arguments `arg1` through `argN` and the object reference `obj` are popped from the stack; the method call is performed with these arguments and control is transferred to the method in `obj` referred to by the method metadata token. When complete, a return value is generated by the callee method and sent to the caller.
4. The return value is pushed onto the stack.
The `callvirt` instruction calls a late-bound method on an object. That is, the method is chosen based on the runtime type of `obj` rather than the compile-time class visible in the method pointer. `Callvirt` can be used to call both virtual and instance methods. The `callvirt` instruction may be immediately preceded by a `tail` (<xref:System.Reflection.Emit.OpCodes.Tailcall>) prefix to specify that the current stack frame should be released before transferring control. If the call would transfer control to a method of higher trust than the original method the stack frame will not be released.
The method metadata token provides the name, class and signature of the method to call. The class associated with `obj` is the class of which it is an instance. If the class defines a non-static method that matches the indicated method name and signature, this method is called. Otherwise all classes in the base class chain of this class are checked in order. It is an error if no method is found.
`Callvirt` pops the object and the associated arguments off the evaluation stack before calling the method. If the method has a return value, it is pushed on the stack upon method completion. On the callee side, the `obj` parameter is accessed as argument 0, `arg1` as argument 1, and so on.
The arguments are placed on the stack in left-to-right order. That is, the first argument is computed and placed on the stack, then the second argument, then the third, until all necessary arguments are atop the stack in descending order. The instance reference `obj` (always required for `callvirt`) must be pushed before any of the user-visible arguments. The signature (carried in the metadata token) need not contain an entry in the parameter list for the this pointer.
Note that a virtual method can also be called using the <xref:System.Reflection.Emit.OpCodes.Call> instruction.
<xref:System.MissingMethodException> is thrown if a non-static method with the indicated name and signature could not be found in the class associated with `obj` or any of its base classes. This is typically detected when Microsoft Intermediate Language (MSIL) instructions are converted to native code, rather than at runtime.
<xref:System.NullReferenceException> is thrown if obj is null.
<xref:System.Security.SecurityException> is thrown if system security does not grant the caller access to the called method. The security check may occur when the CIL is converted to native code rather than at run time.
> [!NOTE]
> When calling methods of System.Object on value types, consider using the `constrained` prefix with the `callvirt` instruction. This removes the need to emit different IL depending on whether or not the value type overrides the method, avoiding a potential versioning problem. Consider using the `constrained` prefix when invoking interface methods on value types, since the value type method implementing the interface method can be changed using a `MethodImpl`. These issues are described in more detail in the <xref:System.Reflection.Emit.OpCodes.Constrained> opcode.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `callvirt` opcode:
- ILGenerator.Emit(OpCode, MethodInfo)
- ILGenerator.EmitCall(OpCode, MethodInfo, Type[])
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Castclass">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Castclass;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Castclass" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Castclass" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Castclass As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Castclass;" />
<MemberSignature Language="F#" Value=" staticval mutable Castclass : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Castclass" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<Attributes>
<Attribute FrameworkAlternate="netframework-2.0;netframework-3.0;netframework-3.5;netframework-4.0;netframework-4.5;netframework-4.5.1;netframework-4.5.2;netframework-4.6;netframework-4.6.1;netframework-4.6.2;netframework-4.7;netframework-4.7.1;netframework-4.7.2;xamarinandroid-7.1;xamarinios-10.8;xamarinmac-3.0">
<AttributeName>System.Runtime.InteropServices.ComVisible(true)</AttributeName>
</Attribute>
</Attributes>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Attempts to cast an object passed by reference to the specified class.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|74 < `T` >|castclass `class`|Casts an object to a new object of type `class`.|
The stack transitional behavior, in sequential order, is:
1. An object reference is pushed onto the stack.
2. The object reference is popped from the stack; the referenced object is cast as the specified `class`.
3. If successful, a new object reference is pushed onto the stack.
The `castclass` instruction attempts to cast the object reference (type `O`) atop the stack to a specified class. The new class is specified by a metadata token indicating the desired class. If the class of the object on the top of the stack does not implement the new class (assuming the new class is an interface) and is not a derived class of the new class then an <xref:System.InvalidCastException> is thrown. If the object reference is a null reference, `castclass` succeeds and returns the new object as a null reference.
<xref:System.InvalidCastException> is thrown if obj cannot be cast to class.
<xref:System.TypeLoadException> is thrown if class cannot be found. This is typically detected when a Microsoft Intermediate Language (MSIL) instruction is converted to native code rather than at runtime.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `castclass` opcode:
- ILGenerator.Emit(OpCode, Type)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Ceq">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Ceq;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Ceq" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Ceq" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Ceq As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Ceq;" />
<MemberSignature Language="F#" Value=" staticval mutable Ceq : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Ceq" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Compares two values. If they are equal, the integer value 1 <see langword="(int32" />) is pushed onto the evaluation stack; otherwise 0 (<see langword="int32" />) is pushed onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|FE 01|ceq|Pushes 1 if `value1` equals `value2`; else pushes 0.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; `value1` is compared to `value2`.
4. If `value1` is equal to `value2`, 1 is pushed onto the stack; otherwise 0 is pushed onto the stack.
The `ceq` instruction compares `value1` and `value2`. If `value1` is equal to `value2`, then 1 (of type `int32`) is pushed on the stack. Otherwise 0 (of type `int32`) is pushed on the stack.
For floating-point number, `ceq` will return 0 if the numbers are unordered (either or both are NaN). The infinite values are equal to themselves.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `ceq` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Cgt">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Cgt;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Cgt" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Cgt" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Cgt As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Cgt;" />
<MemberSignature Language="F#" Value=" staticval mutable Cgt : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Cgt" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Compares two values. If the first value is greater than the second, the integer value 1 <see langword="(int32" />) is pushed onto the evaluation stack; otherwise 0 (<see langword="int32" />) is pushed onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|FE 02|cgt|Pushes 1 if `value1` is greater than `value2`; else pushes 0.|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; `cgt` tests if `value1` is greater than `value2`.
4. If `value1` is greater than `value2`, 1 is pushed onto the stack; otherwise 0 is pushed onto the stack.
The `cgt` instruction compares `value1` and `value2`. If `value1` is strictly greater than `value2`, then an `int32` value of 1 is pushed on the stack. Otherwise, an `int32` value of 0 is pushed on the stack.
- For floating-point numbers, `cgt` returns 0 if the numbers are unordered (that is, if one or both of the arguments are NaN).
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `cgt` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Cgt_Un">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Cgt_Un;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Cgt_Un" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Cgt_Un" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Cgt_Un As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Cgt_Un;" />
<MemberSignature Language="F#" Value=" staticval mutable Cgt_Un : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Cgt_Un" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Compares two unsigned or unordered values. If the first value is greater than the second, the integer value 1 <see langword="(int32" />) is pushed onto the evaluation stack; otherwise 0 (<see langword="int32" />) is pushed onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|FE 03|cgt.un|Pushes 1 if `value1` is greater than `value2`; else pushes 0 (unsigned values).|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; `cgt.un` tests if `value1` is greater than `value2`.
4. If `value1` is greater than `value2`, 1 is pushed onto the stack; otherwise 0 is pushed onto the stack.
An `int32` value of 1 is pushed on the stack if any of the following is `true` :
For floating-point numbers, `value1` is not ordered with respect to `value2`.
For integer values, `value1` is strictly greater than `value2` when considered as unsigned numbers.
Otherwise an `int32` value of 0 is pushed on the stack.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `cgt.un` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Ckfinite">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Ckfinite;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Ckfinite" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Ckfinite" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Ckfinite As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Ckfinite;" />
<MemberSignature Language="F#" Value=" staticval mutable Ckfinite : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Ckfinite" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Throws <see cref="T:System.ArithmeticException" /> if value is not a finite number.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|C3|ckfinite|throw <xref:System.ArithmeticException> if value is not a finite number.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack..
2. `value` is popped from the stack and the `ckfinite` instruction is performed on it.
3. `value` is pushed back onto the stack if no exception is thrown.
The `ckfinite instruction` throws <xref:System.ArithmeticException> if `value` (a floating-point number) is either a "not a number" value (NaN) or a `+-` infinity value. `Ckfinite` leaves the value on the stack if no exception is thrown. Execution is unspecified if `value` is not a floating-point number.
<xref:System.ArithmeticException> is thrown if `value` is not a 'normal' number.
Note that a special exception or a derived class of <xref:System.ArithmeticException> may be more appropriate, passing the incorrect value to the exception handler.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `ckfinite` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Clt">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Clt;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Clt" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Clt" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Clt As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Clt;" />
<MemberSignature Language="F#" Value=" staticval mutable Clt : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Clt" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Compares two values. If the first value is less than the second, the integer value 1 <see langword="(int32" />) is pushed onto the evaluation stack; otherwise 0 (<see langword="int32" />) is pushed onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|FE 04|clt|Pushes 1 if `value1` is less than `value2`; else pushes 0.|
The stack transitional behavior, in sequential order, is: `value1` is pushed onto the stack.
1. `value2` is pushed onto the stack.
2. `value2` and `value1` are popped from the stack; `clt` tests if `value1` is less than `value2`.
3. If `value1` is less than `value2`, 1 is pushed onto the stack; otherwise 0 is pushed onto the stack.
The `clt` instruction compares `value1` and `value2`. If `value1` is strictly less than `value2`, then an `int32` value of 1 is pushed on the stack. Otherwise, an `int32` value of 0 is pushed on the stack.
- For floating-point numbers, `clt` returns 0 if the numbers are unordered (that is, if one or both of the arguments are NaN).
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `clt` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Clt_Un">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Clt_Un;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Clt_Un" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Clt_Un" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Clt_Un As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Clt_Un;" />
<MemberSignature Language="F#" Value=" staticval mutable Clt_Un : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Clt_Un" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Compares the unsigned or unordered values <paramref name="value1" /> and <paramref name="value2" />. If <paramref name="value1" /> is less than <paramref name="value2" />, then the integer value 1 <see langword="(int32" />) is pushed onto the evaluation stack; otherwise 0 (<see langword="int32" />) is pushed onto the evaluation stack.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|FE 05|clt.un|Pushes 1 if `value1` is less than `value2`; else pushes 0 (unsigned values).|
The stack transitional behavior, in sequential order, is:
1. `value1` is pushed onto the stack.
2. `value2` is pushed onto the stack.
3. `value2` and `value1` are popped from the stack; `clt.un` tests if `value1` is less than `value2`.
4. If `value1` is less than `value2`, 1 is pushed onto the stack; otherwise 0 is pushed onto the stack.
The `clt.un` instruction compares `value1` and `value2`. An `int32` value of 1 is pushed on the stack if any of the following is true:
- `value1` is strictly less than `value2` (as for `clt`).
- For floating-point numbers, `value1` is not ordered with respect to `value2`.
- For integer values, `value1` is strictly less than `value2` when considered as unsigned numbers.
Otherwise, an `int32` value of 0 is pushed on the stack.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `clt.un` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Constrained">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Constrained;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Constrained" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Constrained" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Constrained As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Constrained;" />
<MemberSignature Language="F#" Value=" staticval mutable Constrained : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Constrained" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Constrains the type on which a virtual method call is made.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft intermediate language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|FE 16 < `T` >|constrained. `thisType`|Call a virtual method on a type constrained to be type `T`.|
The `constrained` prefix is permitted only on a `callvirt` instruction.
The state of the MSIL stack at this point must be as follows:
1. A managed pointer, `ptr`, is pushed onto the stack. The type of `ptr` must be a managed pointer (`&`) to `thisType`. Note that this is different from the case of an unprefixed `callvirt` instruction, which expects a reference of `thisType`.
2. Method arguments `arg1` through `argN` are pushed onto the stack, just as with an unprefixed `callvirt` instruction.
The `constrained` prefix is designed to allow `callvirt` instructions to be made in a uniform way independent of whether `thisType` is a value type or a reference type.
When a `callvirt` `method` instruction has been prefixed by `constrained` `thisType`, the instruction is executed as follows:
- If `thisType` is a reference type (as opposed to a value type) then `ptr` is dereferenced and passed as the 'this' pointer to the `callvirt` of `method`.
- If `thisType` is a value type and `thisType` implements `method` then `ptr` is passed unmodified as the 'this' pointer to a `call` `method` instruction, for the implementation of `method` by `thisType`.
- If `thisType` is a value type and `thisType` does not implement `method` then `ptr` is dereferenced, boxed, and passed as the 'this' pointer to the `callvirt` `method` instruction.
This last case can occur only when `method` was defined on <xref:System.Object>, <xref:System.ValueType>, or <xref:System.Enum> and not overridden by `thisType`. In this case, the boxing causes a copy of the original object to be made. However, because none of the methods of <xref:System.Object>, <xref:System.ValueType>, and <xref:System.Enum> modify the state of the object, this fact cannot be detected.
The `constrained` prefix supports IL generators that create generic code. Normally the `callvirt` instruction is not valid on value types. Instead it is required that IL compilers effectively perform the 'this' transformation outlined above at compile time, depending on the type of `ptr` and the method being called. However, when `ptr` is a generic type that is unknown at compile time, it is not possible to make this transformation at compile time.
The `constrained` opcode allows IL compilers to make a call to a virtual function in a uniform way independent of whether `ptr` is a value type or a reference type. Although it is intended for the case where `thisType` is a generic type variable, the `constrained` prefix also works for nongeneric types and can reduce the complexity of generating virtual calls in languages that hide the distinction between value types and reference types.
Using the `constrained` prefix also avoids potential versioning problems with value types. If the `constrained` prefix is not used, different IL must be emitted depending on whether or not a value type overrides a method of System.Object. For example, if a value type `V` overrides the Object.ToString() method, a `call` `V.ToString()` instruction is emitted; if it does not, a `box` instruction and a `callvirt` `Object.ToString()` instruction are emitted. A versioning problem can arise in the former case if the override is later removed, and in the latter case if an override is later added.
The `constrained` prefix can also be used for invocation of interface methods on value types, because the value type method implementing the interface method can be changed using a `MethodImpl`. If the `constrained` prefix is not used, the compiler is forced to choose which of the value type's methods to bind to at compile time. Using the `constrained` prefix allows the MSIL to bind to the method that implements the interface method at run time, rather than at compile time.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `constrained` opcode:
- ILGenerator.Emit(OpCode, Type)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Conv_I">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Conv_I;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Conv_I" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Conv_I" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Conv_I As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Conv_I;" />
<MemberSignature Language="F#" Value=" staticval mutable Conv_I : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Conv_I" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Converts the value on top of the evaluation stack to <see langword="native int" />.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|D3|conv.i|Convert to `native int`, pushing `native int` on stack.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack.
2. `value` is popped from the stack and the conversion operation is attempted.
3. If the conversion is successful, the resulting value is pushed onto the stack.
The `conv.i` opcode converts the `value` on top of the stack to the type specified in the opcode, and leave that converted value on the top of the stack. Integer values of less than 4 bytes are extended to `int32` when they are loaded onto the evaluation stack (unless `conv.i` or `conv.u` is used, in which case the result is also `native int`). Floating-point values are converted to the `F` type.
Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from a `float64` to a `float32`, precision can be lost. If `value` is too large to fit in a `float32 (F)`, positive infinity (if `value` is positive) or negative infinity (if `value` is negative) is returned. If overflow occurs converting one integer type to another, the high order bits are truncated. If the result is smaller than an `int32`, the value is sign-extended to fill the slot.
If overflow occurs converting a floating-point type to an integer the value returned is unspecified.
No exceptions are ever thrown when using this field. See <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I> and <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I_Un> for equivalent instructions that will throw an exception when the result type can not properly represent the result value.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `conv.i` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Conv_I1">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Conv_I1;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Conv_I1" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Conv_I1" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Conv_I1 As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Conv_I1;" />
<MemberSignature Language="F#" Value=" staticval mutable Conv_I1 : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Conv_I1" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Converts the value on top of the evaluation stack to <see langword="int8" />, then extends (pads) it to <see langword="int32" />.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|67|conv.i1|Convert to `int8`, pushing `int32` on stack.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack.
2. `value` is popped from the stack and the conversion operation is attempted.
3. If the conversion is successful, the resulting value is pushed onto the stack.
The `conv.i1` opcode converts the `value` on top of the stack to the type specified in the opcode, and leave that converted value on the top of the stack. Integer values of less than 4 bytes are extended to `int32` when they are loaded onto the evaluation stack (unless `conv.i` or `conv.u` is used, in which case the result is also `native int`). Floating-point values are converted to the `F` type.
Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from a `float64` to a `float32`, precision can be lost. If `value` is too large to fit in a `float32 (F)`, positive infinity (if `value` is positive) or negative infinity (if `value` is negative) is returned. If overflow occurs converting one integer type to another, the high order bits are truncated. If the result is smaller than an `int32`, the value is sign-extended to fill the slot.
If overflow occurs converting a floating-point type to an integer the value returned is unspecified.
No exceptions are ever thrown when using this field. See <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I1> and <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I1_Un> for equivalent instructions that will throw an exception when the result type can not properly represent the result value.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `conv.i1` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Conv_I2">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Conv_I2;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Conv_I2" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Conv_I2" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Conv_I2 As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Conv_I2;" />
<MemberSignature Language="F#" Value=" staticval mutable Conv_I2 : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Conv_I2" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Converts the value on top of the evaluation stack to <see langword="int16" />, then extends (pads) it to <see langword="int32" />.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|68|conv.i2|Convert to `int16`, pushing `int32` on stack.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack.
2. `value` is popped from the stack and the conversion operation is attempted.
3. If the conversion is successful, the resulting value is pushed onto the stack.
The `conv.i2` opcode converts the `value` on top of the stack to the type specified in the opcode, and leave that converted value on the top of the stack. Integer values of less than 4 bytes are extended to `int32` when they are loaded onto the evaluation stack (unless `conv.i` or `conv.u` is used, in which case the result is also `native int`). Floating-point values are converted to the `F` type.
Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from a `float64` to a `float32`, precision can be lost. If `value` is too large to fit in a `float32 (F)`, positive infinity (if `value` is positive) or negative infinity (if `value` is negative) is returned. If overflow occurs converting one integer type to another, the high order bits are truncated. If the result is smaller than an `int32`, the value is sign-extended to fill the slot.
If overflow occurs converting a floating-point type to an integer the value returned is unspecified.
No exceptions are ever thrown when using this field. See <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I2> and <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I2_Un> for equivalent instructions that will throw an exception when the result type can not properly represent the result value.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `conv.i2` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Conv_I4">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Conv_I4;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Conv_I4" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Conv_I4" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Conv_I4 As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Conv_I4;" />
<MemberSignature Language="F#" Value=" staticval mutable Conv_I4 : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Conv_I4" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Converts the value on top of the evaluation stack to <see langword="int32" />.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|69|conv.i4|Convert to `int32`, pushing `int32` on stack.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack.
2. `value` is popped from the stack and the conversion operation is attempted.
3. If the conversion is successful, the resulting value is pushed onto the stack.
The `conv.i4` opcode converts the `value` on top of the stack to the type specified in the opcode, and leave that converted value on the top of the stack. Integer values of less than 4 bytes are extended to `int32` when they are loaded onto the evaluation stack (unless `conv.i` or `conv.u` is used, in which case the result is also `native int`). Floating-point values are converted to the `F` type.
Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from a `float64` to a `float32`, precision can be lost. If `value` is too large to fit in a `float32 (F)`, positive infinity (if `value` is positive) or negative infinity (if `value` is negative) is returned. If overflow occurs converting one integer type to another, the high order bits are truncated. If the result is smaller than an `int32`, the value is sign-extended to fill the slot.
If overflow occurs converting a floating-point type to an integer the value returned is unspecified.
No exceptions are ever thrown when using this field. See <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I4> and <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I4_Un> for equivalent instructions that will throw an exception when the result type can not properly represent the result value.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `conv.i4` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Conv_I8">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Conv_I8;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Conv_I8" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Conv_I8" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Conv_I8 As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Conv_I8;" />
<MemberSignature Language="F#" Value=" staticval mutable Conv_I8 : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Conv_I8" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Converts the value on top of the evaluation stack to <see langword="int64" />.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|6A|conv.i8|Convert to `int64`, pushing `int64` on stack.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack.
2. `value` is popped from the stack and the conversion operation is attempted.
3. If the conversion is successful, the resulting value is pushed onto the stack.
The `conv.i8` opcode converts the `value` on top of the stack to the type specified in the opcode, and leave that converted value on the top of the stack. Integer values of less than 4 bytes are extended to `int32` when they are loaded onto the evaluation stack (unless `conv.i` or `conv.u` is used, in which case the result is also `native int`). Floating-point values are converted to the `F` type.
Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from a `float64` to a `float32`, precision can be lost. If `value` is too large to fit in a `float32 (F)`, positive infinity (if `value` is positive) or negative infinity (if `value` is negative) is returned. If overflow occurs converting one integer type to another, the high order bits are truncated. If the result is smaller than an `int32`, the value is sign-extended to fill the slot.
If overflow occurs converting a floating-point type to an integer the value returned is unspecified.
No exceptions are ever thrown when using this field. See <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I8> and <xref:System.Reflection.Emit.OpCodes.Conv_Ovf_I8_Un> for equivalent instructions that will throw an exception when the result type can not properly represent the result value.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `conv.i8` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Conv_Ovf_I">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Conv_Ovf_I;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Conv_Ovf_I" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Conv_Ovf_I" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Conv_Ovf_I As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Conv_Ovf_I;" />
<MemberSignature Language="F#" Value=" staticval mutable Conv_Ovf_I : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Conv_Ovf_I" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>
<Docs>
<summary>Converts the signed value on top of the evaluation stack to signed <see langword="native int" />, throwing <see cref="T:System.OverflowException" /> on overflow.</summary>
<remarks>
<format type="text/markdown"><![CDATA[
## Remarks
The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:
|Format|Assembly Format|Description|
|------------|---------------------|-----------------|
|D4|conv.ovf.i|Convert to a `native int` (on the stack as `native int`) and throw an exception on overflow.|
The stack transitional behavior, in sequential order, is:
1. `value` is pushed onto the stack.
2. `value` is popped from the stack and the conversion operation is attempted. If overflow occurs, an exception is thrown.
3. If the conversion is successful, the resulting value is pushed onto the stack.
The `conv.ovf.i` opcode converts the `value` on top of the stack to the type specified in the opcode, and places that converted value on the top of the stack. If the value is too large or too small to be represented by the target type, an exception is thrown.
Conversions from floating-point numbers to integer values truncate the number toward zero. Note that integer values of less than 4 bytes are extended to `int32` when they are loaded onto the evaluation stack (unless `conv.ovf.i` or `conv.ovf.u` are used, in which case the result is also `native int`).
<xref:System.OverflowException> is thrown if the result can not be represented in the result type.
The following <xref:System.Reflection.Emit.ILGenerator.Emit%2A> method overload can use the `conv.ovf.i` opcode:
- ILGenerator.Emit(OpCode)
]]></format>
</remarks>
</Docs>
</Member>
<Member MemberName="Conv_Ovf_I_Un">
<MemberSignature Language="C#" Value="public static readonly System.Reflection.Emit.OpCode Conv_Ovf_I_Un;" />
<MemberSignature Language="ILAsm" Value=".field public static initonly valuetype System.Reflection.Emit.OpCode Conv_Ovf_I_Un" />
<MemberSignature Language="DocId" Value="F:System.Reflection.Emit.OpCodes.Conv_Ovf_I_Un" />
<MemberSignature Language="VB.NET" Value="Public Shared ReadOnly Conv_Ovf_I_Un As OpCode " />
<MemberSignature Language="C++ CLI" Value="public: static initonly System::Reflection::Emit::OpCode Conv_Ovf_I_Un;" />
<MemberSignature Language="F#" Value=" staticval mutable Conv_Ovf_I_Un : System.Reflection.Emit.OpCode" Usage="System.Reflection.Emit.OpCodes.Conv_Ovf_I_Un" />
<MemberType>Field</MemberType>
<AssemblyInfo>
<AssemblyName>System.Reflection.Primitives</AssemblyName>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
<AssemblyVersion>4.1.0.0</AssemblyVersion>
<AssemblyVersion>4.1.1.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>mscorlib</AssemblyName>
<AssemblyVersion>1.0.5000.0</AssemblyVersion>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
<AssemblyVersion>2.0.5.0</AssemblyVersion>
<AssemblyVersion>4.0.0.0</AssemblyVersion>
</AssemblyInfo>
<AssemblyInfo>
<AssemblyName>netstandard</AssemblyName>
<AssemblyVersion>2.0.0.0</AssemblyVersion>
</AssemblyInfo>
<ReturnValue>
<ReturnType>System.Reflection.Emit.OpCode</ReturnType>
</ReturnValue>