en-US/ILAssembler-help.xml
|
<?xml version="1.0" encoding="utf-8"?>
<helpItems schema="maml" xmlns="http://msh"> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>add</name> <verb>add</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Adds two values and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 58 | add |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>Overflow is not detected for integer operations (for proper overflow handling, see `add.ovf`).</para> <para>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.</para> <para>Floating-point overflow returns `+inf` (`PositiveInfinity`) or `-inf` (`NegativeInfinity`).</para> <para>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.</para> <para>| 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` | `*` |</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">add</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.add</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>add.ovf</name> <verb>add.ovf</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Adds two integers, performs an overflow check, and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | D6 | add.ovf |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>`System.OverflowException` is thrown if the result is not represented in the result type.</para> <para>You can perform this operation on signed integers. For floating-point values, use `add`.</para> <para>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.</para> <para>| 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` | `*` |</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">add.ovf</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.add_ovf</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>add.ovf.un</name> <verb>add.ovf.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Adds two unsigned integer values, performs an overflow check, and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | D7 | add.ovf.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>`System.OverflowException` is thrown if the result is not represented in the result type.</para> <para>You can perform this operation on signed integers. For floating-point values, use `add`.</para> <para>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.</para> <para>| 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` | `*` |</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">add.ovf.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.add_ovf_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>and</name> <verb>and</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Computes the bitwise AND of two values and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Instruction | | ------ | ----------- | | 5F | and |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `and` instruction computes the bitwise AND of the top two values on the stack and leaves the result on the stack.</para> <para>`and` is an integer-specific operation.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">and</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.and</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>arglist</name> <verb>arglist</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Returns an unmanaged pointer to the argument list of the current method.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 00 | arglist |</para> <para>No evaluation stack behaviors are performed by this operation.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">arglist</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.arglist</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>beq</name> <verb>beq</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction if two values are equal.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 3B < `int32` > | beq `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>The acceptable operand types are encapsulated below:</para> <para>If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes.</para> <para>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 `leave` instruction instead).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">beq <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.beq</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>beq.s</name> <verb>beq.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction (short form) if two values are equal.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | --------------- | | 2E < `int8` > | beq.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>The acceptable operand types are encapsulated below:</para> <para>If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes.</para> <para>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 `leave` instruction instead).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">beq.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.beq_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bge</name> <verb>bge</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction if the first value is greater than or equal to the second value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------ | --------------- | | 3C `<int32>` | bge `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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` instruction (`clt.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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bge <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bge</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bge.s</name> <verb>bge.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction (short form) if the first value is greater than or equal to the second value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ----------- | --------------- | | 2F `<int8>` | bge.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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` instruction (`clt.un` 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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bge.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bge_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bge.un</name> <verb>bge.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>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.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------ | --------------- | | 41 `<int32>` | bge.un `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.un` instruction (`clt` 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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bge.un <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bge_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bge.un.s</name> <verb>bge.un.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>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.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ----------------- | | 34 < `int8` > | bge.un.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.un` instruction (`clt` 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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bge.un.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bge_un_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bgt</name> <verb>bgt</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction if the first value is greater than the second value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 3D < `int32` > | bgt `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bgt <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bgt</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bgt.s</name> <verb>bgt.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction (short form) if the first value is greater than the second value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | --------------- | | 30 < `int8` > | bgt.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bgt.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bgt_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bgt.un</name> <verb>bgt.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>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.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 42 < `int32` > | bgt.un `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bgt.un <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bgt_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bgt.un.s</name> <verb>bgt.un.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>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.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ----------------- | | 35 < `int8` > | bgt.un.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bgt.un.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bgt_un_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ble</name> <verb>ble</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction if the first value is less than or equal to the second value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------ | --------------- | | 3E `<int32>` | ble `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ble <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ble</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ble.s</name> <verb>ble.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction (short form) if the first value is less than or equal to the second value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ----------- | --------------- | | 31 `<int8>` | ble.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ble.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ble_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ble.un</name> <verb>ble.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>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.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------ | --------------- | | 43 `<int32>` | ble.un `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ble.un <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ble_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ble.un.s</name> <verb>ble.un.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>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.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ----------- | ----------------- | | 36 `<int8>` | ble.un.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ble.un.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ble_un_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>blt</name> <verb>blt</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction if the first value is less than the second value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 3F < `int32` > | blt `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">blt <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.blt</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>blt.s</name> <verb>blt.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction (short form) if the first value is less than the second value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | --------------- | | 32 < `int8` > | blt.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">blt.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.blt_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>blt.un</name> <verb>blt.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>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.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 44 < `int32` > | blt.un `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">blt.un <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.blt_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>blt.un.s</name> <verb>blt.un.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>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.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ----------------- | | 37 < `int8` > | blt.un.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">blt.un.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.blt_un_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bne.un</name> <verb>bne.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction when two unsigned integer values or unordered float values are not equal.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 40 < `int32` > | bne.un `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bne.un <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bne_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>bne.un.s</name> <verb>bne.un.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction (short form) when two unsigned integer values or unordered float values are not equal.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ----------------- | | 33 < `int8` > | bne.un.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">bne.un.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.bne_un_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>box</name> <verb>box</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts a value type to an object reference (type `O`).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ------------------ | | 8C < `T` > | box `valTypeToken` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>A value type has two separate representations within the Common Language Infrastructure (CLI):</para> <para>- 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. </para> <para>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.</para> <para>`System.OutOfMemoryException` is thrown if there is insufficient memory to satisfy the request.</para> <para>`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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">box <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.box</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>br</name> <verb>br</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Unconditionally transfers control to a target instruction.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 38 < `int32` > | br `target` |</para> <para>No evaluation stack behaviors are performed by this operation.</para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">br <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.br</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>br.s</name> <verb>br.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Unconditionally transfers control to a target instruction (short form).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | --------------- | | 2B < `int8` > | br.s `target` |</para> <para>No evaluation stack behaviors are performed by this operation.</para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">br.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.br_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>break</name> <verb>break</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Signals the Common Language Infrastructure (CLI) to inform the debugger that a break point has been tripped.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 01 | break |</para> <para>No evaluation stack behaviors are performed by this operation.</para> <para>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.</para> <para>The `break` instruction has the smallest possible instruction size enabling code patching with a break point and generating minimal disturbance to the surrounding code.</para> <para>The `break` instruction can trap to a debugger, do nothing, or raise a security exception. The exact behavior is implementation-defined.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">break</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.break</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>brfalse</name> <verb>brfalse</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction if `value` is `false`, a `null` reference (`Nothing` in Visual Basic), or zero.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | ---------------- | | 39 < `int32` > | brfalse `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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`. </para> <para>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.</para> <para>The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">brfalse <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.brfalse</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>brfalse.s</name> <verb>brfalse.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction if `value` is `false`, a `null` reference, or `0`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------ | ------------------ | | 2C <`int8` > | brfalse.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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`. </para> <para>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.</para> <para>The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">brfalse.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.brfalse_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>brtrue</name> <verb>brtrue</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction if `value` is `true`, not `null`, or non-zero.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 3A < `int32` > | brtrue `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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`. </para> <para>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.</para> <para>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 `lDNULL`).</para> <para>The target instruction is represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">brtrue <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.brtrue</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>brtrue.s</name> <verb>brtrue.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control to a target instruction (short form) if `value` is `true`, not `null`, or non-zero.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ----------------- | | 2D < `int8` > | brtrue.s `target` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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`. </para> <para>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.</para> <para>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 `ldnull`).</para> <para>The target instruction is represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">brtrue.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.brtrue_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>call</name> <verb>call</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Calls the method indicated by the passed method descriptor.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ----------------- | | 28 < `T` > | call `methodDesc` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.` 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 `callvirt` instruction for calling virtual methods, where the destination address also depends upon the runtime type of the instance reference pushed before the `callvirt`).</para> <para>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:</para> <para>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. </para> <para>`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.</para> <para>> [!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 `constrained.` opcode.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">call <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.call</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>calli</name> <verb>calli</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Calls the method indicated on the evaluation stack (as a pointer to an entry point) with arguments described by a calling convention.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------------- | | 29 < `T` > | calli `callSiteDescr` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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 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.</para> <para>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 `ldftn` or `ldvirtftn` instructions, or passed in from native code.</para> <para>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.</para> <para>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.</para> <para>`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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">calli <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.calli</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>callvirt</name> <verb>callvirt</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Calls a late-bound method on an object, pushing the return value onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ----------------- | | 6F < `T` > | callvirt `method` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.` 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.</para> <para>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.</para> <para>`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.</para> <para>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.</para> <para>Note that a virtual method can also be called using the `call`> instruction.</para> <para>`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.</para> <para>`System.NullReferenceException` is thrown if obj is null.</para> <para>`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.</para> <para>> [!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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">callvirt <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.callvirt</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>castclass</name> <verb>castclass</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Attempts to cast an object passed by reference to the specified class.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ----------------- | | 74 < `T` > | castclass `class` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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 `System.InvalidCastException` is thrown. If the object reference is a null reference, `castclass` succeeds and returns the new object as a null reference.</para> <para>`System.InvalidCastException` is thrown if obj cannot be cast to class.</para> <para>`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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">castclass <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.castclass</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ceq</name> <verb>ceq</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Compares two values. If they are equal, the integer value `1` (`int32`) is pushed onto the evaluation stack; otherwise `0` (`int32`) is pushed onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 01 | ceq |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ceq</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ceq</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>cgt</name> <verb>cgt</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Compares two values. If the first value is greater than the second, the integer value `1` (`int32`) is pushed onto the evaluation stack; otherwise `0` (`int32`) is pushed onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 02 | cgt |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>- For floating-point numbers, `cgt` returns 0 if the numbers are unordered (that is, if one or both of the arguments are NaN). </para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">cgt</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.cgt</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>cgt.un</name> <verb>cgt.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Compares two unsigned or unordered values. If the first value is greater than the second, the integer value 1 (`int32`) is pushed onto the evaluation stack; otherwise 0 (`int32`) is pushed onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 03 | cgt.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>An `int32` value of 1 is pushed on the stack if any of the following is `true` :</para> <para>For floating-point numbers, `value1` is not ordered with respect to `value2`.</para> <para>For integer values, `value1` is strictly greater than `value2` when considered as unsigned numbers.</para> <para>Otherwise an `int32` value of 0 is pushed on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">cgt.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.cgt_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ckfinite</name> <verb>ckfinite</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Throws `System.ArithmeticException` if value is not a finite number.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | C3 | ckfinite |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `ckfinite` instruction throws `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.</para> <para>`System.ArithmeticException` is thrown if `value` is not a 'normal' number.</para> <para>Note that a special exception or a derived class of `System.ArithmeticException` may be more appropriate, passing the incorrect value to the exception handler.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ckfinite</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ckfinite</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>clt</name> <verb>clt</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Compares two values. If the first value is less than the second, the integer value 1 (`int32`) is pushed onto the evaluation stack; otherwise 0 (`int32`) is pushed onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 04 | clt |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value1` is pushed onto the stack. 2. `value2` is pushed onto the stack. 3. `value2` and `value1` are popped from the stack; `clt` 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. </para> <para>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.</para> <para>- For floating-point numbers, `clt` returns 0 if the numbers are unordered (that is, if one or both of the arguments are NaN). </para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">clt</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.clt</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>clt.un</name> <verb>clt.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Compares the unsigned or unordered values `value1` and `value2`. If `value1` is less than `value2`, then the integer value 1 (`int32`) is pushed onto the evaluation stack; otherwise 0 (`int32`) is pushed onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 05 | clt.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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:</para> <para>- `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. </para> <para>Otherwise, an `int32` value of 0 is pushed on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">clt.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.clt_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>constrained.</name> <verb>constrained.</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Constrains the type on which a virtual method call is made.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft intermediate language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ----------------------- | | FE 16 < `T` > | constrained. `thisType` |</para> <para>The `constrained.` prefix is permitted only on a `callvirt` instruction.</para> <para>The state of the MSIL stack at this point must be as follows:</para> <para>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. </para> <para>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.</para> <para>When a `callvirt` `method` instruction has been prefixed by `constrained.` `thisType`, the instruction is executed as follows:</para> <para>- 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. </para> <para>This last case can occur only when `method` was defined on `stem.Object`, `System.ValueType`, or `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 `System.Object`, `System.ValueType`, and `System.Enum` modify the state of the object, this fact cannot be detected.</para> <para>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.</para> <para>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.</para> <para>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.</para> <para>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.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">constrained. <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.constrained</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.i</name> <verb>conv.i</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `native int`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | D3 | conv.i |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.i` and `conv.ovf.i.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.i</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_i</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.i1</name> <verb>conv.i1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `int8`, then extends (pads) it to `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 67 | conv.i1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.I1` and `conv.ovf.i1.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.i1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_i1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.i2</name> <verb>conv.i2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `int16`, then extends (pads) it to `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 68 | conv.i2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.i2` and `conv.ovf.i2.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.i2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_i2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.i4</name> <verb>conv.i4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 69 | conv.i4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.i4` and `conv.ovf.i4.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.i4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_i4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.i8</name> <verb>conv.i8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `int64`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 6A | conv.i8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.i8` and `conv.ovf.i8.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.i8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_i8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i</name> <verb>conv.ovf.i</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to signed `native int`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | D4 | conv.ovf.i |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i.un</name> <verb>conv.ovf.i.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to signed `native int`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 8A | conv.ovf.i.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.i.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i1</name> <verb>conv.ovf.i1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to signed `int8` and extends it to `int32`, throwing `System.OverflowException` /> on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | B3 | conv.ovf.i1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.i1` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i1.un</name> <verb>conv.ovf.i1.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to signed `int8` and extends it to `int32`, throwing `System.OverflowException` /> on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 82 | conv.ovf.i1.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.i1.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i1.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i1_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i2</name> <verb>conv.ovf.i2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to signed `int16` and extending it to `int32`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | B5 | conv.ovf.i2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.i2` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i2.un</name> <verb>conv.ovf.i2.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to signed `int16` and extends it to `int32`, throwing `System.OverflowException` /> on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 83 | conv.ovf.i2.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.i2.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i2.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i2_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i4</name> <verb>conv.ovf.i4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to signed `int32`, throwing `System.OverflowException` /> on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | B7 | conv.ovf.i4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.i4` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i4.un</name> <verb>conv.ovf.i4.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to signed `int32`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 84 | conv.ovf.i4.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.i4.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i4.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i4_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i8</name> <verb>conv.ovf.i8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to signed `int64`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | B9 | conv.ovf.i8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.i8` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.i8.un</name> <verb>conv.ovf.i8.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to signed `int64`, throwing `System.OverflowException` /> on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 85 | conv.ovf.i8.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.i8.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.i8.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_i8_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u</name> <verb>conv.ovf.u</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to `unsigned native int`, throwing `System.OverflowException` /> on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | D5 | conv.ovf.u |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u.un</name> <verb>conv.ovf.u.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to `unsigned native int`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 8B | conv.ovf.u.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u1</name> <verb>conv.ovf.u1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to `unsigned int8` and extends it to `int32`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | B4 | conv.ovf.u1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u1` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u1.un</name> <verb>conv.ovf.u1.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to `unsigned int8` and extends it to `int32`, throwing `System.OverflowException` /> on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 86 | conv.ovf.u1.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u1.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u1.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u1_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u2</name> <verb>conv.ovf.u2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to `unsigned int16` and extends it to `int32`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | B6 | conv.ovf.u2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u2` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u2.un</name> <verb>conv.ovf.u2.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to `unsigned int16` and extends it to `int32`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 87 | conv.ovf.u2.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u2.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u2.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u2_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u4</name> <verb>conv.ovf.u4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to `unsigned int32`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | B8 | conv.ovf.u4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u4` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u4.un</name> <verb>conv.ovf.u4.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to `unsigned int32`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 88 | conv.ovf.u4.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u4.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u4.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u4_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u8</name> <verb>conv.ovf.u8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the signed value on top of the evaluation stack to `unsigned int64`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | BA | conv.ovf.u8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u8` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.ovf.u8.un</name> <verb>conv.ovf.u8.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned value on top of the evaluation stack to `unsigned int64`, throwing `System.OverflowException` on overflow.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 89 | conv.ovf.u8.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.ovf.u8.un` 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.</para> <para>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`).</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.ovf.u8.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_ovf_u8_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.r.un</name> <verb>conv.r.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the unsigned integer value on top of the evaluation stack to `float32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 76 | conv.r.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.r.un` 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.</para> <para>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.</para> <para>If overflow occurs converting a floating-point type to an integer the `result` returned is unspecified. The `conv.r.un` operation takes an integer off the stack, interprets it as unsigned, and replaces it with a floating-point number to represent the integer: either a `float32`, if this is wide enough to represent the integer without loss of precision, or else a `float64`.</para> <para>No exceptions are ever thrown when using this field.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.r.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_r_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.r4</name> <verb>conv.r4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `float32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 6B | conv.r4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.r4` 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.</para> <para>Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from an `float64` to an `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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.r4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_r4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.r8</name> <verb>conv.r8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `float64`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 6C | conv.r8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.r8` 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.</para> <para>Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from an `float64` to an `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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.r8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_r8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.u</name> <verb>conv.u</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `unsigned native int`, and extends it to `native int`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | E0 | conv.u |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.u` 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.</para> <para>Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from an `float64` to an `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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.i` and `conv.ovf.i.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.u</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_u</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.u1</name> <verb>conv.u1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `unsigned int8`, and extends it to `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | D2 | conv.u1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.u1` 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.</para> <para>Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from an `float64` to an `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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.i1` and `conv.ovf.i1.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.u1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_u1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.u2</name> <verb>conv.u2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `unsigned int16`, and extends it to `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | D1 | conv.u2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.u2` 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.</para> <para>Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from an `float64` to an `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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.i2` and `conv.ovf.i2.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.u2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_u2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.u4</name> <verb>conv.u4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `unsigned int32`, and extends it to `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 6D | conv.u4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.u4` 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.</para> <para>Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from an `float64` to an `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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.i4` and `conv.ovf.i4.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.u4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_u4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>conv.u8</name> <verb>conv.u8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the value on top of the evaluation stack to `unsigned int64`, and extends it to `int64`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 6E | conv.u8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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. </para> <para>The `conv.u8` 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.</para> <para>Conversion from floating-point numbers to integer values truncates the number toward zero. When converting from an `float64` to an `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.</para> <para>If overflow occurs converting a floating-point type to an integer the value returned is unspecified.</para> <para>No exceptions are ever thrown when using this field. See `conv.ovf.i8` and `conv.ovf.i8.un` for equivalent instructions that will throw an exception when the result type can not properly represent the result value.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">conv.u8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.conv_u8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>cpblk</name> <verb>cpblk</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Copies a specified number bytes from a source address to a destination address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 17 | cpblk |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The destination address is pushed onto the stack. 2. The source address is pushed onto the stack. 3. The number of bytes to copy is pushed onto the stack. 4. The number of bytes, the source address, and the destination address are popped from the stack; the specified number of bytes are copied from the source address to the destination address. </para> <para>The `cpblk` instruction copies a number (type `unsigned int32`) of bytes from a source address (of type `*`, `native int`, or `&`) to a destination address (of type `*`, `native int`, or `&`). The behavior of `cpblk` is unspecified if the source and destination areas overlap.</para> <para>`cpblk` assumes that both the source and destination addressed are aligned to the natural size of the machine. The `cpblk` instruction can be immediately preceded by the `unaligned.<prefix>` instruction to indicate that either the source or the destination is unaligned.</para> <para>The operation of the `cpblk` instruction can be altered by an immediately preceding `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` may be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">cpblk</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.cpblk</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>cpobj</name> <verb>cpobj</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Copies the value type located at the address of an object (type "`&`", `*` or `native int`) to the address of the destination object (type `&`, `*` or `native int`).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ---------------- | | 70 < `T` > | cpobj `classTok` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The destination object reference is pushed onto the stack. 2. The source object reference is pushed onto the stack. 3. The two object references are popped from the stack; the value type at the address of the source object is copied to the address of the destination object. </para> <para>The behavior of `cpobj` is unspecified if the source and destination object references are not pointers to instances of the class represented by the class token `classTok` (a `typeref` or `typedef`), or if `classTok` does not represent a value type.</para> <para>`System.NullReferenceException` may be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">cpobj <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.cpobj</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>div</name> <verb>div</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Divides two values and pushes the result as a floating-point (type `F`) or quotient (type `int32`) onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 5B | div |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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 divided by `value2`. 4. The result is pushed onto the stack. </para> <para>`result` = `value1` div value2 satisfies the following conditions:</para> <para>| `result` | = | `value1` | / | `value2` |, and:</para> <para>sign(`result`) = +, if sign(`value1`) = sign(`value2`), or -, if sign(`value1`) ~= sign(`value2`)</para> <para>The `div` instruction computes the result and pushes it on the stack.</para> <para>Integer division truncates towards zero.</para> <para>Division of a finite number by zero produces the correctly signed infinite value.</para> <para>Dividing zero by zero or infinity by infinity produces the NaN (Not-A-Number) value. Any number divided by infinity will produce a zero value.</para> <para>Integral operations throw `System.ArithmeticException` if the result cannot be represented in the result type. This can happen if `value1` is the maximum negative value, and `value2` is -1.</para> <para>Integral operations throw `System.DivideByZeroException` if `value2` is zero.</para> <para>Note that on Intel-based platforms an `System.OverflowException` is thrown when computing (minint div -1). Floating-point operations never throw an exception (they produce NaNs or infinities instead).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">div</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.div</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>div.un</name> <verb>div.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Divides two unsigned integer values and pushes the result (`int32`) onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 5C | div.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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 divided by `value2`. 4. The result is pushed onto the stack. </para> <para>The `div.un` instruction computes `value1` divided by `value2`, both taken as unsigned integers, and pushes the `result` on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">div.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.div_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>dup</name> <verb>dup</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Copies the current topmost value on the evaluation stack, and then pushes the copy onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 25 | dup |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value` is pushed onto the stack. 2. `value` is popped off of the stack for duplication. 3. `value` is pushed back onto the stack. 4. A duplicate value is pushed onto the stack. </para> <para>The `dup` instruction duplicates the top element of the stack, and leaves two identical values atop it.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">dup</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.dup</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>endfilter</name> <verb>endfilter</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control from the `filter` clause of an exception back to the Common Language Infrastructure (CLI) exception handler.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 11 | endfilter |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value` is pushed onto the stack. 2. `value` is popped from the stack; `endfilter` is executed and control is transferred to the exception handler. </para> <para>`Value` (which must be of type `int32` and is one of a specific set of values) is returned from the filter clause. It should be one of:</para> <para>- `exception_continue_search` (`value` = 0) to continue searching for an exception handler - `exception_execute_handler` (`value` = 1) to start the second phase of exception handling where finally blocks are run until the handler associated with this filter clause is located. Upon discovery, the handler is executed. </para> <para>Other integer values will produce unspecified results.</para> <para>The entry point of a filter, as shown in the method's exception table, must be the first instruction in the filter's code block. The `endfilter` instruction must be the last instruction in the filter's code block (hence there can only be one `endfilter` for any single filter block). After executing the `endfilter` instruction, control logically flows back to the CLI exception handling mechanism.</para> <para>Control cannot be transferred into a filter block except through the exception mechanism. Control cannot be transferred out of a filter block except through the use of a `throw` instruction or by executing the final `endfilter` instruction. You cannot embed a `try` block within a `filter` block. If an exception is thrown inside the `filter` block, it is intercepted and a value of 0 (`exception_continue_search`) is returned.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">endfilter</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.endfilter</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>endfinally</name> <verb>endfinally</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Transfers control from the `fault` or `finally` clause of an exception block back to the Common Language Infrastructure (CLI) exception handler.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------------- | | DC | endfinally / endfault |</para> <para>There are no stack transition behaviors for this instruction.</para> <para>`Endfinally` and `endfault` signal the end of the `finally` or `fault` clause so that stack unwinding can continue until the exception handler is invoked. The `endfinally` or `endfault` instruction transfers control back to the CLI exception mechanism. The mechanism then searches for the next `finally` clause in the chain if the protected block was exited with a leave instruction. If the protected block was exited with an exception, the CLI will search for the next `finally` or `fault`, or enter the exception handler chosen during the first pass of exception handling.</para> <para>An `endfinally` instruction might only appear lexically within a `finally` block. Unlike the `endfilter` instruction, there is no requirement that the block end with an `endfinally` instruction, and there can be as many `endfinally` instructions within the block as required. These same restrictions apply to the `endfault` instruction and the `fault` block.</para> <para>Control cannot be transferred into a `finally` (or `fault`) block except through the exception mechanism. Control cannot be transferred out of a `finally` (or `fault`) block except through the use of a `throw` instruction or executing the `endfinally` (or `endfault`) instruction. In particular, you cannot "fall out" of a `finally` (or `fault`) block or to execute a `ret` or `leave` instruction within a `finally` (or `fault`) block.</para> <para>Note that the `endfault` and `endfinally` instructions are aliases - they correspond to the same opcode.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">endfinally</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.endfinally</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>initblk</name> <verb>initblk</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Initializes a specified block of memory at a specific address to a given size and initial value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 18 | initblk |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A starting address is pushed onto the stack. 2. An initialization value is pushed onto the stack. 3. The number of bytes to initialize is pushed onto the stack. 4. The number of bytes, the initialization value, and the starting address are popped from the stack, and the initialization is performed as per their values. </para> <para>The `initblk` instruction sets the number (`unsigned int32`) of bytes starting at the specified address (of type `native int`, `&`, or `*`) to the initialization value (of type `unsigned int8`). `initblk` assumes that the starting address is aligned to the natural size of the machine.</para> <para>The operation of the `initblk` instructions can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` may be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">initblk</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.initblk</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>initobj</name> <verb>initobj</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Initializes each field of the value type at a specified address to a null reference or a 0 of the appropriate primitive type.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ------------------- | | FE 15 < `T` > | `initobj` `typeTok` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The address of the value type to initialize is pushed onto the stack. 2. The address is popped from the stack; the value type at the specified address is initialized as type `typeTok`. </para> <para>The `initobj` instruction initializes each field of the value type specified by the pushed address (of type `native int`, `&`, or `*`) to a null reference or a 0 of the appropriate primitive type. After this method is called, the instance is ready for a constructor method to be called. If `typeTok` is a reference type, this instruction has the same effect as `ldnull` followed by `stind.ref`.</para> <para>Unlike `newobj`, `initobj` does not call the constructor method. `initobj` is intended for initializing value types, while `newobj` is used to allocate and initialize objects.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">initobj <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.initobj</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>isinst</name> <verb>isinst</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Tests whether an object reference (type `O`) is an instance of a particular class.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 75 < `T` > | isinst `class` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference is pushed onto the stack. 2. The object reference is popped from the stack and tested to see if it is an instance of the class passed in `class`. 3. The result (either an object reference or a null reference) is pushed onto the stack. </para> <para>`class` is a metadata token indicating the desired class. If the class of the object on the top of the stack implements `class` (if `class` is an interface) or is a derived class of `class` (if `class` is a regular class) then it is cast to type `class` and the result is pushed on the stack, exactly as though `castclass` had been called. Otherwise, a null reference is pushed on the stack. If the object reference itself is a null reference, then `isinst` likewise returns a null reference.</para> <para>`System.TypeLoadException` is thrown if class cannot be found. This is typically detected when the Microsoft Intermediate Language (MSIL) instructions are converted to native code rather than at runtime.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">isinst <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.isinst</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>jmp</name> <verb>jmp</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Exits current method and jumps to specified method.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 27 < `T` > | jmp `method` |</para> <para>There are no stack transition behaviors for this instruction.</para> <para>The `jmp` (jump) instruction transfers control to the method specified by `method`, which is a metadata token for a method reference. The current arguments are transferred to the destination method.</para> <para>The evaluation stack must be empty when this instruction is executed. The calling convention, number and type of arguments at the destination address must match that of the current method.</para> <para>The `jmp` instruction cannot be used to transferred control out of a `try`, `filter`, `catch`, or `finally` block.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">jmp <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.jmp</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldarg.0</name> <verb>ldarg.0</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the argument at index 0 onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 02 | ldarg.0 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The argument value at index 0 is pushed onto the stack. </para> <para>The `ldarg.0` instruction is an efficient encoding for loading the argument value at index 0.</para> <para>The `ldarg.0` instruction pushes the argument indexed at 0 onto the evaluation stack. The `ldarg.0` instruction can be used to load a value type or a primitive value onto the stack by copying it from an incoming argument. The type of the argument value is the same as the type of the argument, as specified by the current method's signature.</para> <para>Arguments that hold an integer value smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldarg.0</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldarg_0</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldarg.1</name> <verb>ldarg.1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the argument at index 1 onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 03 | ldarg.1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The argument value at index 1 is pushed onto the stack. </para> <para>The `ldarg.1` instruction is an efficient encoding for loading the argument value at index 1.</para> <para>The `ldarg.1` instruction pushes the argument indexed at 1 onto the evaluation stack. The `ldarg.1` instruction can be used to load a value type or a primitive value onto the stack by copying it from an incoming argument. The type of the argument value is the same as the type of the argument, as specified by the current method's signature.</para> <para>Arguments that hold an integer value smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldarg.1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldarg_1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldarg.2</name> <verb>ldarg.2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the argument at index 2 onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 04 | ldarg.2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The argument value at index 2 is pushed onto the stack. </para> <para>The `ldarg.2` instruction is an efficient encoding for loading the argument value at index 2.</para> <para>The `ldarg.2` instruction pushes the argument indexed at 2 onto the evaluation stack. The `ldarg.2` instruction can be used to load a value type or a primitive value onto the stack by copying it from an incoming argument. The type of the argument value is the same as the type of the argument, as specified by the current method's signature.</para> <para>Arguments that hold an integer value smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldarg.2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldarg_2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldarg.3</name> <verb>ldarg.3</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the argument at index 3 onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 05 | ldarg.3 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The argument value at index 3 is pushed onto the stack. </para> <para>The `ldarg.3` instruction is an efficient encoding for loading the argument value at index 3.</para> <para>The `ldarg.3` instruction pushes the argument indexed at 3 onto the evaluation stack. The `ldarg.3` instruction can be used to load a value type or a primitive value onto the stack by copying it from an incoming argument. The type of the argument value is the same as the type of the argument, as specified by the current method's signature.</para> <para>Arguments that hold an integer value smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldarg.3</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldarg_3</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldarg</name> <verb>ldarg</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads an argument (referenced by a specified index value) onto the stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------------------- | --------------- | | FE 09 < `unsigned int16` > | ldarg `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The argument value at `index` is pushed onto the stack. </para> <para>The `ldarg` instruction pushes the argument indexed at `index`, where arguments are indexed from 0 onwards, onto the evaluation stack. The `ldarg` instruction can be used to load a value type or a primitive value onto the stack by copying it from an incoming argument. The type of the argument value is the same as the type of the argument, as specified by the current method's signature.</para> <para>For procedures that take a variable-length argument list, the `ldarg` instruction can be used only for the initial fixed arguments, not those in the variable part of the signature (see the `arglist` instruction for more details).</para> <para>Arguments that hold an integer value smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldarg <int32></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">int32</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">int32</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldarg</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldarg.s</name> <verb>ldarg.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the argument (referenced by a specified short form index) onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------------------- | --------------- | | 0E < `unsigned int8` > | ldarg.s `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The argument value at `index` is pushed onto the stack. </para> <para>The `ldarg.s` instruction is an efficient encoding for loading arguments indexed from 4 through 255.</para> <para>The `ldarg.s` instruction pushes the argument indexed at `index`, where arguments are indexed from 0 onwards, onto the evaluation stack. The `ldarg.s` instruction can be used to load a value type or a primitive value onto the stack by copying it from an incoming argument. The type of the argument value is the same as the type of the argument, as specified by the current method's signature.</para> <para>For procedures that take a variable-length argument list, the `ldarg.s` instruction can be used only for the initial fixed arguments, not those in the variable part of the signature (see the `arglist` instruction for more details).</para> <para>Arguments that hold an integer value smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldarg.s <byte></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">byte</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">byte</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldarg_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldarga</name> <verb>ldarga</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Load an argument address onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------------------- | --------------- | | FE 0A < `unsigned int16` > | ldarga `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The address `addr` of the argument indexed by `index` is pushed onto the stack. </para> <para>The `ldarga` instruction fetches the address (of type `*`) of the argument indexed by `index`, where arguments are indexed from 0 onwards. The address `addr` is always aligned to a natural boundary on the target machine.</para> <para>For procedures that take a variable-length argument list, the `ldarga` instruction can be used only for the initial fixed arguments, not those in the variable part of the signature.</para> <para>`ldarga` is used for by-ref parameter passing. For other cases, `ldarg` and `starg` should be used.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldarga <int32></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">int32</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">int32</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldarga</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldarga.s</name> <verb>ldarga.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Load an argument address, in short form, onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------------------- | ---------------- | | 0F < `unsigned int8` > | ldarga.s `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The address `addr` of the argument indexed by `index` is pushed onto the stack. </para> <para>`ldarga.s` (the short form of `ldarga`) should be used for argument numbers 0 through 255, and is a more efficient encoding.</para> <para>The `ldarga.s` instruction fetches the address (of type`*`) of the argument indexed by `index`, where arguments are indexed from 0 onwards. The address `addr` is always aligned to a natural boundary on the target machine.</para> <para>For procedures that take a variable-length argument list, the `ldarga.s` instruction can be used only for the initial fixed arguments, not those in the variable part of the signature.</para> <para>`ldarga.s` is used for by-ref parameter passing. For other cases, `ldarg.s` and `starg.s` should be used.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldarga.s <byte></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">byte</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">byte</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldarga_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.0</name> <verb>ldc.i4.0</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of 0 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 16 | ldc.i4.0 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value 0 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value 0. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.0</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_0</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.1</name> <verb>ldc.i4.1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of 1 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 17 | ldc.i4.1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value 1 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value 1. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.2</name> <verb>ldc.i4.2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of 2 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 18 | ldc.i4.2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value 2 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value 2. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.3</name> <verb>ldc.i4.3</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of 3 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 19 | ldc.i4.3 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value 3 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value 3. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.3</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_3</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.4</name> <verb>ldc.i4.4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of 4 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 1A | ldc.i4.4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value 4 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value 4. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.5</name> <verb>ldc.i4.5</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of 4 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 1B | ldc.i4.5 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value 5 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value 5. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.5</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_5</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.6</name> <verb>ldc.i4.6</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of 4 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 1C | ldc.i4.6 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value 6 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value 6. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.6</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_6</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.7</name> <verb>ldc.i4.7</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of 4 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 1D | ldc.i4.7 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value 7 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value 7. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.7</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_7</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.8</name> <verb>ldc.i4.8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of 4 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 1E | ldc.i4.8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value 8 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value 8. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.m1</name> <verb>ldc.i4.m1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the integer value of -1 onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 15 | ldc.i4.m1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value -1 is pushed onto the stack. </para> <para>This is a special short encoding for the push of the integer value -1. All special short encodings push 4 byte integers on the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.m1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_m1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4</name> <verb>ldc.i4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes a supplied value of type `int32` onto the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 20 < `int32` > | ldc.i4 `num` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value `num` is pushed onto the stack. </para> <para>Note that there are special short (and hence more efficient) encodings for the integers -128 through 127, and especially short encodings for -1 through 8. All short encodings push 4 byte integers on the stack. Longer encodings are used for 8 byte integers and 4 and 8 byte floating-point numbers, as well as 4-byte values that do not fit in the short forms. There are three ways to push an 8 byte integer constant onto the stack</para> <para>1. Use the `ldc.i8` instruction for constants that must be expressed in more than 32 bits. 2. Use the `ldc.i4` instruction followed by a `conv.i8` for constants that require 9 to 32 bits. 3. Use a short form instruction followed by a `conv.i8` for constants that can be expressed in 8 or fewer bits. </para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4 <int32></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">value</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the constant to push onto the stack.</para> </Description> <parameterValue required="true" variableLength="false">int32</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">int32</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i4.s</name> <verb>ldc.i4.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the supplied `int8` value onto the evaluation stack as an `int32`, short form.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | --------------- | | 1F < `int8` > | ldc.i4.s `num` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value `num` is pushed onto the stack. </para> <para>`ldc.i4.s` is a more efficient encoding for pushing the integers from -128 to 127 onto the evaluation stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i4.s <byte></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">value</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the constant to push onto the stack.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i4_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.i8</name> <verb>ldc.i8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes a supplied value of type `int64` onto the evaluation stack as an `int64`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | 21 < `int64` > | ldc.i8 `num` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value `num` is pushed onto the stack. </para> <para>This encoding pushes an `int64` value onto the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.i8 <int64></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">value</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the constant to push onto the stack.</para> </Description> <parameterValue required="true" variableLength="false">int64</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">int64</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_i8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.r4</name> <verb>ldc.r4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes a supplied value of type `float32` onto the evaluation stack as type `F` (float).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------------- | --------------- | | 22 < `float32` > | ldc.r4 `num` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value `num` is pushed onto the stack. </para> <para>This encoding pushes a `float32` value onto the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.r4 <float></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">value</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the constant to push onto the stack.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_r4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldc.r8</name> <verb>ldc.r8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes a supplied value of type `float64` onto the evaluation stack as type `F` (float).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------------- | --------------- | | 23 < `float64` > | ldc.r8 `num` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value `num` is pushed onto the stack. </para> <para>This encoding pushes a `float64` value onto the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldc.r8 <double></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">value</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the constant to push onto the stack.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldc_r8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.i</name> <verb>ldelem.i</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `native int` at a specified array index onto the top of the evaluation stack as a `native int`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 97 | ldelem.i |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.i` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.i` is `native int`.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.i</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_i</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.i1</name> <verb>ldelem.i1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `int8` at a specified array index onto the top of the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 90 | ldelem.i1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.i1` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.i1` is `int8`.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.i1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_i1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.i2</name> <verb>ldelem.i2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `int16` at a specified array index onto the top of the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 92 | ldelem.i2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.i2` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.i2` is `int16`.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.i2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_i2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.i4</name> <verb>ldelem.i4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `int32` at a specified array index onto the top of the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 94 | ldelem.i4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.i4` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.i4` is `int32`.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.i4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_i4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.i8</name> <verb>ldelem.i8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `int64` at a specified array index onto the top of the evaluation stack as an `int64`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 96 | ldelem.i8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.i8` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.i8` is `int64`.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.i8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_i8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem</name> <verb>ldelem</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element at a specified array index onto the top of the evaluation stack as the type specified in the instruction.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft intermediate language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ---------------- | | A3 < `T` > | ldelem `typeTok` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects, and hence represented by a value of type `O`.</para> <para>The type of the return value is specified by the token `typeTok` in the instruction.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the upper bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.r4</name> <verb>ldelem.r4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `float32` at a specified array index onto the top of the evaluation stack as type `F` (float).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 98 | ldelem.r4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.r4` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.r4` is `float32`.</para> <para>Floating-point values are converted to type `F` when loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.r4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_r4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.r8</name> <verb>ldelem.r8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `float64` at a specified array index onto the top of the evaluation stack as type `F` (float).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 99 | ldelem.r8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.r8` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.r8` is `float64`.</para> <para>Floating-point values are converted to type `F` when loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.r8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_r8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.ref</name> <verb>ldelem.ref</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element containing an object reference at a specified array index onto the top of the evaluation stack as type `O` (object reference).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 9A | ldelem.ref |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.ref` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.ref` is type `O` (object reference).</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.ref</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_ref</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.u1</name> <verb>ldelem.u1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `unsigned int8` at a specified array index onto the top of the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 91 | ldelem.u1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.u1` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.u1` is `int8`.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.u1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_u1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.u2</name> <verb>ldelem.u2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `unsigned int16` at a specified array index onto the top of the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 93 | ldelem.u2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.u2` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.u2` is `int16`.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.u2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_u2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelem.u4</name> <verb>ldelem.u4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the element with type `unsigned int32` at a specified array index onto the top of the evaluation stack as an `int32`.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 95 | ldelem.u4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the value stored at position `index` in `array` is looked up. 4. The value is pushed onto the stack. </para> <para>The `ldelem.u4` instruction loads the value of the element with index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`.</para> <para>The return value for `ldelem.u4` is `int32`.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if array does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelem.u4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelem_u4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldelema</name> <verb>ldelema</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the address of the array element at a specified array index onto the top of the evaluation stack as type `&` (managed pointer).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 8F < `T` > | ldelema `class` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `array` is pushed onto the stack. 2. An index value `index` is pushed onto the stack. 3. `index` and `array` are popped from the stack; the address stored at position `index` in `array` is looked up. 4. The address is pushed onto the stack. </para> <para>The `ldelema` is used to retrieve the address of an object at a particular index in an array of objects (of type `class`). The `ldelema` instruction loads the address of the value at index `index` (type `native int`) in the zero-based one-dimensional array `array` and places it on the top of the stack. Arrays are objects and hence represented by a value of type `O`. The value must be of type `class` passed with the instruction.</para> <para>The return value for `ldelema` is a managed pointer (type `&`).</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldelema <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldelema</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldfld</name> <verb>ldfld</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Finds the value of a field in the object whose reference is currently on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 7B < `T` > | ldfld `field` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference (or pointer) is pushed onto the stack. 2. The object reference (or pointer) is popped from the stack; the value of the specified field in the object is found. 3. The value stored in the field is pushed onto the stack. </para> <para>The `ldfld` instruction pushes the value of a field located in an object onto the stack. The object must be on the stack as an object reference (type `O`), a managed pointer (type `&`), an unmanaged pointer (type `native int`), a transient pointer (type `*`), or an instance of a value type. The use of an unmanaged pointer is not permitted in verifiable code. The object's field is specified by a metadata token that must refer to a field member. The return type is the same as the one associated with the field. The field may be either an instance field (in which case the object must not be a null reference) or a static field.</para> <para>The `ldfld` instruction can be preceded by either or both of the `unaligned.` and `volatile.` prefixes.</para> <para>`System.NullReferenceException` is thrown if the object is null and the field is not static.</para> <para>`System.MissingFieldException` is thrown if the specified field is not found in the metadata. This is typically checked when Microsoft Intermediate Language (MSIL) instructions are converted to native code, not at run time.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldfld <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldfld</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldflda</name> <verb>ldflda</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Finds the address of a field in the object whose reference is currently on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 7C < `T` > | ldflda `field` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference (or pointer) is pushed onto the stack. 2. The object reference (or pointer) is popped from the stack; the address of the specified field in the object is found. 3. The address of the specified field is pushed onto the stack. </para> <para>The `ldflda` instruction pushes the address of a field located in an object onto the stack. The object must be on the stack as an object reference (type `O`), a managed pointer (type `&`), an unmanaged pointer (type `native int`), a transient pointer (type `*`), or an instance of a value type. The use of an unmanaged pointer is not permitted in verifiable code. The object's field is specified by a metadata token that must refer to a field member.</para> <para>The value returned by `ldflda` is a managed pointer (type `&`) unless the object is pushed onto the stack as an unmanaged pointer, in which case the return address is also an unmanaged pointer (type `native int`).</para> <para>The `ldflda` instruction can be preceded by either or both of the `unaligned.` and `volatile.` prefixes.</para> <para>`System.InvalidOperationException` is thrown if the object is not within the application domain from which it is being accessed. The address of a field that is not inside the accessing application domain cannot be loaded.</para> <para>`System.NullReferenceException` is thrown if the object is null and the field is not static.</para> <para>`System.MissingFieldException` is thrown if the specified field is not found in the metadata. This is typically checked when Microsoft Intermediate Language (MSIL) instructions are converted to native code, not at run time.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldflda <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldflda</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldftn</name> <verb>ldftn</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes an unmanaged pointer (type `native int`) to the native code implementing a specific method onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | --------------- | | FE 06 < `T` > | ldftn `method` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The unmanaged pointer to a specific method is pushed onto the stack. </para> <para>The specific method (`method`) can be called using the `calli` instruction if it references a managed method (or a stub that transitions from managed to unmanaged code).</para> <para>The value returned points to native code using the CLR calling convention. This method pointer should not be passed to unmanaged native code as a callback routine.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldftn <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldftn</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.i</name> <verb>ldind.i</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `native int` as a `native int` onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 4D | ldind.i |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.i` instruction indirectly loads a `native int` value from the specified address (of type `native int`, `&`, or *) onto the stack as a `native int`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.i</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_i</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.i1</name> <verb>ldind.i1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `int8` as an `int32` onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 46 | ldind.i1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.i1` instruction indirectly loads an `int8` value from the specified address (of type `native int`, `&`, or *) onto the stack as an `int32`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.i1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_i1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.i2</name> <verb>ldind.i2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `int16` as an `int32` onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 48 | ldind.i2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.i2` instruction indirectly loads an `int16` value from the specified address (of type `native int`, `&`, or *) onto the stack as an `int32`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.i2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_i2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.i4</name> <verb>ldind.i4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `int32` as an `int32` onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 4A | ldind.i4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.i4` instruction indirectly loads an `int32` value from the specified address (of type `native int`, `&`, or *) onto the stack as an `int32`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.i4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_i4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.i8</name> <verb>ldind.i8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `int64` as an `int64` onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 4C | ldind.i8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.i8` instruction indirectly loads an `int64` value from the specified address (of type `native int`, `&`, or *) onto the stack as an `int64`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.i8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_i8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.r4</name> <verb>ldind.r4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `float32` as a type `F` (float) onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 4E | ldind.r4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.r4` instruction indirectly loads a `float32` value from the specified address (of type `native int`, `&`, or *) onto the stack as a type `F`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.r4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_r4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.r8</name> <verb>ldind.r8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `float64` as a type `F` (float) onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 4F | ldind.r8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.r8` instruction indirectly loads a `float64` value from the specified address (of type `native int`, `&`, or *) onto the stack as a `float64`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.r8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_r8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.ref</name> <verb>ldind.ref</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads an object reference as a type `O` (object reference) onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 50 | ldind.ref |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the object reference located at the address is fetched. 3. The fetched reference is pushed onto the stack. </para> <para>The `ldind.ref` instruction indirectly loads the object reference the specified address (of type `native int`, `&`, or *) onto the stack as type `O`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.ref</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_ref</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.u1</name> <verb>ldind.u1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `unsigned int8` as an `int32` onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 47 | ldind.u1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.u1` instruction indirectly loads an `unsigned int8` value from the specified address (of type`native int`, `&`, or *) onto the stack as an `int32`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.u1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_u1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.u2</name> <verb>ldind.u2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `unsigned int16` as an `int32` onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 49 | ldind.u2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.u2` instruction indirectly loads an `unsigned int16` value from the specified address (of type `native int`, `&`, or *) onto the stack as an `int32`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.u2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_u2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldind.u4</name> <verb>ldind.u4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads a value of type `unsigned int32` as an `int32` onto the evaluation stack indirectly.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 4B | ldind.u4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. The address is popped from the stack; the value located at the address is fetched. 3. The fetched value is pushed onto the stack. </para> <para>The `ldind.u4` instruction indirectly loads an `unsigned int32` value from the specified address (of type `native int`, `&`, or *) onto the stack as an `int32`.</para> <para>All of the `ldind` instructions are shortcuts for a `ldobj` instruction that specifies the corresponding built-in value class.</para> <para>Note that integer values of less than 4 bytes are extended to `int32` (not `native int`) when they are loaded onto the evaluation stack. Floating-point values are converted to `F` type when loaded onto the evaluation stack.</para> <para>Correctly-formed Microsoft Intermediate Language (MSIL) ensures that the `ldind` instructions are used in a manner consistent with the type of the pointer.</para> <para>The address initially pushed onto the stack must be aligned to the natural size of objects on the machine or a `System.NullReferenceException` can occur (see the `unaligned.` prefix instruction for preventative measures). The results of all MSIL instructions that return addresses (for example, `ldloca` and `ldarga`) are safely aligned. For datatypes larger than 1 byte, the byte ordering is dependent on the target CPU. Code that depends on byte ordering might not run on all platforms.</para> <para>`System.NullReferenceException` can be thrown if an invalid address is detected.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldind.u4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldind_u4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldlen</name> <verb>ldlen</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the number of elements of a zero-based, one-dimensional array onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 8E | ldlen |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array is pushed onto the stack. 2. The array reference is popped from the stack and the length is computed. 3. The length is pushed onto the stack. </para> <para>Arrays are objects and hence represented by a value of type `O`. The length is returned as a `natural unsigned int`.</para> <para>`System.NullReferenceException` is thrown if the array reference is a null reference.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldlen</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldlen</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloc.0</name> <verb>ldloc.0</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the local variable at index 0 onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 06 | ldloc.0 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The local variable value at the index 0 is pushed onto the stack. </para> <para>`ldloc.0` is an especially efficient encoding for `ldloc`, allowing access to the local variable at index 0.</para> <para>The type of the value is the same as the type of the local variable, which is specified in the method header. Local variables that are smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloc.0</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldloc_0</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloc.1</name> <verb>ldloc.1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the local variable at index 1 onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 07 | ldloc.1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The local variable value at the index 1 is pushed onto the stack. </para> <para>`ldloc.1` is an especially efficient encoding for `ldloc`, allowing access to the local variable at index 1.</para> <para>The type of the value is the same as the type of the local variable, which is specified in the method header. Local variables that are smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloc.1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldloc_1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloc.2</name> <verb>ldloc.2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the local variable at index 2 onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | Description | | ------ | --------------- | -------------------------------------------------------------- | | 08 | ldloc.2 | Loads the local variable at index 2 onto the evaluation stack. |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The local variable value at the index 2 is pushed onto the stack. </para> <para>`ldloc.2` is an especially efficient encoding for `ldloc`, allowing access to the local variable at index 2.</para> <para>The type of the value is the same as the type of the local variable, which is specified in the method header. Local variables that are smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloc.2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldloc_2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloc.3</name> <verb>ldloc.3</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the local variable at index 3 onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 09 | ldloc.3 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The local variable value at the index 3 is pushed onto the stack. </para> <para>`ldloc.3` is an especially efficient encoding for `ldloc`, allowing access to the local variable at index 3.</para> <para>The type of the value is the same as the type of the local variable, which is specified in the method header. Local variables that are smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloc.3</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldloc_3</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloc.auto</name> <verb>ldloc.auto</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the specified local variable evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The `ldloc.auto` instruction is a meta instruction specific to the `ILAssembler` PowerShell module. By passing a variable expression (e.g. `$varName`) that corresponds with a local defined in the `.locals` directive, this instruction will be replaced with the most appropriate `ldloc*` instruction.</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The local variable value specified by the variable expression is pushed onto the stack. </para> <para>The type of the value is the same as the type of the local variable, which is specified in the method header. See Partition I. Local variables that are smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloc.auto <psvariable></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">variable</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the variable to load.</para> </Description> <parameterValue required="true" variableLength="false">psvariable</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">psvariable</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://github.com/SeeminglyScience/ILAssembler/blob/master/docs/en-US/ldloc.auto.md</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloc</name> <verb>ldloc</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the local variable at a specific index onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------------------- | --------------- | | FE 0C < `unsigned int16` > | ldloc `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The local variable value at the specified index is pushed onto the stack. </para> <para>The `ldloc` instruction pushes the contents of the local variable number at the passed index onto the evaluation stack, where the local variables are numbered 0 onwards. Local variables are initialized to 0 before entering the method only if the initialize flag on the method is true. There are 65,535 (2^16-1) local variables possible (0-65,534). Index 65,535 is not valid since likely implementations will use a 2-byte integer to track both a local's index, along with the total number of locals for a given method. If an index of 65535 had been made valid, it would require a wider integer to track the number of locals in such a method.</para> <para>The `ldloc.0`, `ldloc.1`, `ldloc.2`, and `ldloc.3` instructions provide an efficient encoding for accessing the first four local variables.</para> <para>The type of the value is the same as the type of the local variable, which is specified in the method header. See Partition I. Local variables that are smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloc <int32></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">int32</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">int32</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldloc</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloc.s</name> <verb>ldloc.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the local variable at a specific index onto the evaluation stack, short form.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------------------- | --------------- | | 11 < `unsigned int8` > | ldloc.s `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The local variable value at the specified index is pushed onto the stack. </para> <para>The `ldloc.s` instruction pushes the contents of the local variable number at the passed index onto the evaluation stack, where the local variables are numbered 0 onwards. Local variables are initialized to 0 before entering the method if the initialize flag on the method is true. There are 256 (2^8) local variables possible (0-255) in the short form, which is a more efficient encoding than `ldloc`.</para> <para>The type of the value is the same as the type of the local variable, which is specified in the method header. See Partition I. Local variables that are smaller than 4 bytes long are expanded to type `int32` when they are loaded onto the stack. Floating-point values are expanded to their native size (type `F`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloc.s <byte></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">byte</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">byte</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldloc_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloca.auto</name> <verb>ldloca.auto</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the address of the specified local variable onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The `ldloca.auto` instruction is a meta instruction specific to the `ILAssembler` PowerShell module. By passing a variable expression (e.g. `$varName`) that corresponds with a local defined in the `.locals` directive, this instruction will be replaced with the most appropriate `ldloca*` instruction.</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The address stored in the specified local variable is pushed onto the stack. </para> <para>The `ldloca.auto` instruction pushes the address of the local variable number at the passed index onto the stack, where local variables are numbered 0 onwards. The value pushed on the stack is already aligned correctly for use with instructions like `ldind.i` and `stind.i`. The result is a transient pointer (type `*`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloca.auto <psvariable></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">variable</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the variable to load.</para> </Description> <parameterValue required="true" variableLength="false">psvariable</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">psvariable</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://github.com/SeeminglyScience/ILAssembler/blob/master/docs/en-US/ldloca.auto.md</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloca</name> <verb>ldloca</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the address of the local variable at a specific index onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------------------- | --------------- | | FE OD < `unsigned int16` > | ldloca `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The address stored in the local variable at the specified index is pushed onto the stack. </para> <para>The `ldloca` instruction pushes the address of the local variable number at the passed index onto the stack, where local variables are numbered 0 onwards. The value pushed on the stack is already aligned correctly for use with instructions like `ldind.i` and `stind.i`. The result is a transient pointer (type `*`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloca <int32></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">int32</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">int32</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldloca</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldloca.s</name> <verb>ldloca.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Loads the address of the local variable at a specific index onto the evaluation stack, short form.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------------------- | ---------------- | | 12 < `unsigned int8` > | ldloca.s `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The address stored in the local variable at the specified index is pushed onto the stack. </para> <para>The `ldloca.s` instruction pushes the address of the local variable number at the passed index onto the stack, where local variables are numbered 0 onwards. The value pushed on the stack is already aligned correctly for use with instructions like `ldind.i` and `stind.i`. The result is a transient pointer (type `*`).</para> <para>The `ldloca.s` instruction provides an efficient encoding for use with the local variables 0 through 255.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldloca.s <byte></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">byte</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">byte</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldloca_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldnull</name> <verb>ldnull</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes a null reference (type `O`) onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 14 | ldnull |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A null object reference is pushed onto the stack. </para> <para>`ldnull` pushes a null reference (type `O`) on the stack. This is used to initialize locations before they are populated with data, or when they become deprecated.</para> <para>`ldnull` provides a null reference that is size-independent.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldnull</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldnull</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldobj</name> <verb>ldobj</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Copies the value type object pointed to by an address to the top of the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 71 < `T` > | ldobj `class` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The address of a value type object is pushed onto the stack. 2. The address is popped from the stack and the instance at that particular address is looked up. 3. The value of the object stored at that address is pushed onto the stack. </para> <para>The `ldobj` instruction is used to pass a value type as a parameter.</para> <para>The `ldobj` instruction copies the value pointed to by `addrOfValObj` (of type `&`, `*`, or `native int`) to the top of the stack. The number of bytes copied depends on the size of the class (as specified by the `class` parameter). The `class` parameter is a metadata token representing the value type.</para> <para>The operation of the `ldobj` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.TypeLoadException` is thrown if class cannot be found. This is typically detected when the Microsoft Intermediate Language (MSIL) instruction is converted to native code rather than at runtime.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldobj <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldobj</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldsfld</name> <verb>ldsfld</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the value of a static field onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 7E < `T` > | ldsfld `field` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value of the specific field is pushed onto the stack. </para> <para>The `ldsfld` instruction pushes the value of a static (shared among all instances of a class) field on the stack. The return type is that associated with the passed metadata token `field`.</para> <para>The `ldsfld` instruction can have a `volatile.` prefix.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldsfld <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldsfld</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldsflda</name> <verb>ldsflda</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the address of a static field onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 7F < `T` > | ldsflda `field` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The address of a specific field is pushed onto the stack. </para> <para>The `ldsflda` instruction pushes the address of a static (shared among all instances of a class) field on the stack. The address may be represented as a transient pointer (type `*`) if the metadata token `field` refers to a type whose memory is managed. Otherwise, it corresponds to an unmanaged pointer (type `native int`). Note that `field` may be a static global with an assigned relative virtual address (the offset of the field from the base address at which its containing PE file is loaded into memory) where the memory is unmanaged.</para> <para>The `ldsflda` instruction can have a `volatile.` prefix.</para> <para>`System.MissingFieldException` is thrown if field is not found in the metadata. This is typically checked when Microsoft Intermediate Language (MSIL) instructions are converted to native code, not at runtime.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldsflda <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldsflda</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldstr</name> <verb>ldstr</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes a new object reference to a string literal stored in the metadata.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 72 < `T` > | ldstr `mdToken` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to a string is pushed onto the stack. </para> <para>The `ldstr` instruction pushes an object reference (type `O`) to a new string object representing the specific string literal stored in the metadata. The `ldstr` instruction allocates the requisite amount of memory and performs any format conversion required to convert the string literal from the form used in the file to the string format required at runtime.</para> <para>The Common Language Infrastructure (CLI) guarantees that the result of two `ldstr` instructions referring to two metadata tokens that have the same sequence of characters return precisely the same string object (a process known as "string interning").</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldstr <string></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">value</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the constant to push onto the stack.</para> </Description> <parameterValue required="true" variableLength="false">string</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">string</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldstr</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldtoken</name> <verb>ldtoken</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts a metadata token to its runtime representation, pushing it onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | D0 < `T` > | ldtoken `token` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The passed token is converted to a `RuntimeHandle` and pushed onto the stack. </para> <para>The `ldtoken` instruction pushes a `RuntimeHandle` for the specified metadata token. A `RuntimeHandle` can be a `fieldref/fielddef`, a `methodref/methoddef`, or a `typeref/typedef`.</para> <para>The value pushed on the stack can be used in calls to `Reflection` methods in the system class library.</para> <para>For information on runtime handles, see the following classes: `System.RuntimeFieldHandle`, `System.RuntimeTypeHandle`, and `System.RuntimeMethodHandle`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldtoken <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldtoken</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ldvirtftn</name> <verb>ldvirtftn</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes an unmanaged pointer (type `native int`) to the native code implementing a particular virtual method associated with a specified object onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ------------------ | | FE 07 < `T` > | ldvirtftn `method` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference is pushed onto the stack. 2. The object reference is popped from the stack and the address of the entry point to the method (as specified by the metadata token `method`) is looked up. 3. The pointer to `method` is pushed onto the stack. </para> <para>The resulting unmanaged pointer pushed onto the stack by the `ldvirtftn` instruction can be called using the `calli` instruction if it references a managed method (or a stub that transitions from managed to unmanaged code).</para> <para>The unmanaged pointer points to native code using the CLR calling convention. This method pointer should not be passed to unmanaged native code as a callback routine.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ldvirtftn <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ldvirtftn</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>leave</name> <verb>leave</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Exits a protected region of code, unconditionally transferring control to a specific target instruction.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------- | --------------- | | DD < `int32` > | leave `target` |</para> <para>There is no stack transition behavior specified for this instruction.</para> <para>The `leave` instruction unconditionally transfers control to the specific target instruction, represented as a 4-byte signed offset from the beginning of the instruction following the current instruction.</para> <para>The `leave` instruction is similar to the `br` instruction, but it can be used to exit a `try`, `filter`, or `catch` block whereas the ordinary branch instructions can only be used in such a block to transfer control within it. The `leave` instruction empties the evaluation stack and ensures that the appropriate surrounding `finally` blocks are executed.</para> <para>You cannot use a `leave` instruction to exit a `finally` block. To ease code generation for exception handlers it is valid from within a catch block to use a `leave` instruction to transfer control to any instruction within the associated `try` block.</para> <para>If an instruction has one or more prefix codes, control can only be transferred to the first of these prefixes.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">leave <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.leave</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>leave.s</name> <verb>leave.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Exits a protected region of code, unconditionally transferring control to a target instruction (short form).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ---------------- | | DE < `int8` > | leave.s `target` |</para> <para>There is no stack transition behavior specified for this instruction.</para> <para>The `leave.s` instruction unconditionally transfers control to the passed target instruction, represented as a 1-byte signed offset from the beginning of the instruction following the current instruction.</para> <para>The `leave.s` instruction is similar to the `br` instruction, but it can be used to exit a `try`, `filter`, or `catch` block whereas the ordinary branch instructions can only be used in such a block to transfer control within it. The `leave.s` instruction empties the evaluation stack and ensures that the appropriate surrounding `finally` blocks are executed.</para> <para>You cannot use a `leave.s` instruction to exit a `finally` block. To ease code generation for exception handlers it is valid from within a catch block to use a `leave.s` instruction to transfer control to any instruction within the associated `try` block.</para> <para>If an instruction has one or more prefix codes, control can only be transferred to the first of these prefixes.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">leave.s <branch_name></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the label representing the target offset.</para> </Description> <parameterValue required="true" variableLength="false">branch_name</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.leave_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>localloc</name> <verb>localloc</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Allocates a certain number of bytes from the local dynamic memory pool and pushes the address (a transient pointer, type `*`) of the first allocated byte onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 0F | localloc |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The number of bytes to be allocated is pushed onto the stack. 2. The number of bytes is popped from the stack; an amount of memory corresponding to the size is allocated from the local heap. 3. A pointer to the first byte of the allocated memory is pushed onto the stack. </para> <para>The `localloc` instruction allocates `size` (type `natural unsigned int`) bytes from the local dynamic memory pool and returns the address (a transient pointer, type `*`) of the first allocated byte. The block of memory returned is initialized to 0 only if the initialize flag on the method is `true`. When the current method executes a `ret`, the local memory pool is made available for reuse.</para> <para>The resulting address is aligned so that any primitive data type can be stored there using the `stind` instructions (such as `stind.i4`) and loaded using the `ldind` instructions (such as `ldind.i4`).</para> <para>The `localloc` instruction cannot occur within a `filter`, `catch`, `finally`, or `fault` block.</para> <para>`System.StackOverflowException` is thrown if there is insufficient memory to service the request.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">localloc</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.localloc</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>mkrefany</name> <verb>mkrefany</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes a typed reference to an instance of a specific type onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ---------------- | | C6 < `T` > | mkrefany `class` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A pointer to piece of data is pushed onto the stack. 2. The pointer is popped and converted to a typed reference of type `class`. 3. The typed reference is pushed onto the stack. </para> <para>The `mkrefany` instruction supports the passing of dynamically typed references. The pointer must be of type `&`, `*`, or `native int`, and hold the valid address of a piece of data. `Class` is the class token describing the type of the data referenced by the pointer. `Mkrefany` pushes a typed reference on the stack, providing an opaque descriptor of the pointer and the type `class`.</para> <para>The only valid operation permitted upon a typed reference is to pass it to a method that requires a typed reference as a parameter. The callee can then use the `refanytype` and `refanyval` instructions to retrieve the type (class) and the address respectively.</para> <para>`System.TypeLoadException` is thrown if `class` cannot be found. This is typically detected when Microsoft Intermediate Language (MSIL) instructions are converted to native code rather than at runtime.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">mkrefany <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.mkrefany</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>mul</name> <verb>mul</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Multiplies two values and pushes the result on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 5A | mul |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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 multiplied by `value2`. 4. The result is pushed onto the stack. </para> <para>The `mul` instruction multiplies `value1` by `value2` and pushes the result on the stack. Integer operations silently truncate the upper bits on overflow.</para> <para>See `mul.ovf` for an integer-specific multiply operation with overflow handling.</para> <para>For floating-point types, 0 * infinity = NaN.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">mul</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.mul</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>mul.ovf</name> <verb>mul.ovf</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Multiplies two integer values, performs an overflow check, and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | D8 | mul.ovf |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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 multiplied by `value2`, with an overflow check. 4. The result is pushed onto the stack. </para> <para>The `mul.ovf` instruction multiplies integer `value1` by integer `value2` and pushes the result on the stack. An exception is thrown if the result will not fit in the result type.</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">mul.ovf</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.mul_ovf</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>mul.ovf.un</name> <verb>mul.ovf.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Multiplies two unsigned integer values, performs an overflow check, and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | D9 | mul.ovf.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>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 multiplied by `value2`, with an overflow check. 4. The result is pushed onto the stack. </para> <para>The `mul.ovf.un` instruction multiplies unsigned integer `value1` by unsigned integer `value2` and pushes the result on the stack. An exception is thrown if the result will not fit in the result type.</para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">mul.ovf.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.mul_ovf_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>neg</name> <verb>neg</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Negates a value and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 65 | neg |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is pushed onto the stack. 2. A value is popped from the stack and negated. 3. The result is pushed onto the stack. </para> <para>The `neg` instruction negates value and pushes the result on top of the stack. The return type is the same as the operand type.</para> <para>Negation of integral values is standard two's complement negation. In particular, negating the most negative number (which does not have a positive counterpart) yields the most negative number. To detect this overflow use the `sub.ovf` instruction instead (that is, subtract from 0).</para> <para>Negating a floating-point number cannot overflow, and negating NaN returns NaN.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">neg</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.neg</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>newarr</name> <verb>newarr</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes an object reference to a new zero-based, one-dimensional array whose elements are of a specific type onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 8D < `T` > | newarr `etype` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The number of elements in the array is pushed onto the stack. 2. The number of elements is popped from the stack and the array is created. 3. An object reference to the new array is pushed onto the stack. </para> <para>The `newarr` instruction pushes an object reference (type `O`) to a new zero-based, one-dimensional array whose elements are of type `etype` (a metadata token describing the type). The number of elements in the new array should be specified as a `native int`. Valid array indexes range from zero to the maximum number of elements minus one.</para> <para>The elements of an array can be any type, including value types.</para> <para>Zero-based, one-dimensional arrays of numbers are created using a metadata token referencing the appropriate value type (`System.Int32`, and so on). Elements of the array are initialized to 0 of the appropriate type.</para> <para>Nonzero-based one-dimensional arrays and multidimensional arrays are created using `newobj` rather than `newarr`. More commonly, they are created using the methods of the `System.Array` class in the .NET Framework.</para> <para>`System.OutOfMemoryException` is thrown if there is insufficient memory to satisfy the request.</para> <para>`System.OverflowException` is thrown if `numElems` is less than 0.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">newarr <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.newarr</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>New-IlDelegate</name> <verb>New</verb> <noun>IlDelegate</noun> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The New-IlDelegate command creates a invokable delegate using from the provided common intermediate language (CIL) instructions.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Provides an entry point for a domain specific language (DSL) resembling that of ILAsm.exe. When invoked, the `ScriptBlock` provided by the `Body` parameter is analyzed for matching instructions. If analysis is successful, the CIL is encoded into a `DynamicMethod` and a delegate is generated.</para> <para>During the creation of the delegate, no PowerShell code is actually invoked. Instead, the abstract syntax tree is traversed statically.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">New-IlDelegate [-Signature] <ScriptBlock> [-Body] <ScriptBlock></name> </syntaxItem> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">New-IlDelegate [-DelegateType] <Type> [-Body] <ScriptBlock></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">Body</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the block of CIL instructions to assemble.</para> </Description> <parameterValue required="true" variableLength="false">ScriptBlock</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ScriptBlock</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="0" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">DelegateType</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the delegate type to return. Use this parameter only if you need a delegate of a specific kind to pass to an existing .NET API.</para> </Description> <parameterValue required="true" variableLength="false">Type</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">Type</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="0" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">Signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies an anonymous method signature block used to determine parameters and return type. This block may include any parameter types that are valid in a method signature. Types that are not valid as generic parameters (such as `byref`, `byreflike` or pointer types) will result in the generation of a suitable delegate type.</para> </Description> <parameterValue required="true" variableLength="false">ScriptBlock</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ScriptBlock</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This command does not accept input from the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">System.Delegate</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This command emits an invokable subclass of `System.Delegate` to the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples> <example> <title xmlns="http://schemas.microsoft.com/maml/2004/10">-------------------------- EXAMPLE 1 --------------------------</title> <code xmlns="http://schemas.microsoft.com/maml/dev/2004/10">```powershell il { [void]([int]) } { ldarg.0 call { [void] [Console]::Write([int]) } ret } ```</code> <remarks xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <para xmlns="http://schemas.microsoft.com/maml/2004/10">Defines a delegate with a void return that takes an int as a parameter.</para> </remarks> </example> <example> <title xmlns="http://schemas.microsoft.com/maml/2004/10">-------------------------- EXAMPLE 2 --------------------------</title> <code xmlns="http://schemas.microsoft.com/maml/dev/2004/10">```powershell il { [int]@() } { ldc.i4.0 ret } ```</code> <remarks xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <para xmlns="http://schemas.microsoft.com/maml/2004/10">Defines a delegate that returns int and does not have any parameters.</para> </remarks> </example> <example> <title xmlns="http://schemas.microsoft.com/maml/2004/10">-------------------------- EXAMPLE 3 --------------------------</title> <code xmlns="http://schemas.microsoft.com/maml/dev/2004/10">```powershell il System.AsyncCallback { ldarg.0 callvirt { [object] [IAsyncResult].get_AsyncState() } call { [void] [Console]::Write([object]) } ret } ```</code> <remarks xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <para xmlns="http://schemas.microsoft.com/maml/2004/10">Defines a delegate of type `System.AsyncCallback`.</para> </remarks> </example> <example> <title xmlns="http://schemas.microsoft.com/maml/2004/10">-------------------------- EXAMPLE 4 --------------------------</title> <code xmlns="http://schemas.microsoft.com/maml/dev/2004/10">```powershell il { [string]([ref] [int] $sum, [int+] $intsPointer, [int] $intsCount) } { .locals init { [int] $i, } # i = 0 ldc.i4.0 stloc.0 br.s condition loop_start: # sum (ld location to eval stack for the stind.i4 later) ldarg.0 # *sum ldarg.0 ldind.i4 # intsPointer[i] ldarg.1 ldloc.0 conv.i sizeof { [int] } mul add ldind.i4 # *sum + intsPointer[i] add # *sum = *sum + intsPointer[i] stind.i4 # i++ ldloc.0 ldc.i4.1 add stloc.0 condition: # if (i < intsCount) goto loop_start ldloc.0 ldarg.2 blt.s loop_start # return sum.ToString() ldarg.0 call { [string] [int].ToString() } ret } ```</code> <remarks xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <para xmlns="http://schemas.microsoft.com/maml/2004/10">Defines a delegate that returns string and takes int&, int*, and int as parameters.</para> </remarks> </example> </examples> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://github.com/SeeminglyScience/ILAssembler/blob/master/docs/en-US/New-ILDelegate.md</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>newobj</name> <verb>newobj</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Creates a new object or a new instance of a value type, pushing an object reference (type `O`) onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 73 < `T` > | newobj `ctor` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. Arguments `arg1` through `argn` are pushed on the stack in sequence. 2. Arguments `argn` through `arg1` are popped from the stack and passed to `ctor` for object creation. 3. A reference to the new object is pushed onto the stack. </para> <para>The `newobj` instruction creates a new object or a new instance of a value type. `Ctor` is a metadata token (a `methodref` or `methoddef` that must be marked as a constructor) that indicates the name, class and signature of the constructor to call.</para> <para>The `newobj` instruction allocates a new instance of the class associated with `ctor` and initializes all the fields in the new instance to 0 (of the proper type) or null references as appropriate. It then calls the constructor `ctor` with the given arguments along with the newly created instance. After the constructor has been called, the now initialized object reference (type `O`) is pushed on the stack.</para> <para>From the constructor's point of view, the uninitialized object is argument 0 and the other arguments passed to newobj follow in order.</para> <para>All zero-based, one-dimensional arrays are created using `newarr`, not `newobj`. On the other hand, all other arrays (more than one dimension, or one-dimensional but not zero-based) are created using `newobj`.</para> <para>Value types are not usually created using `newobj`. They are usually allocated either as arguments or local variables, using `newarr` (for zero-based, one-dimensional arrays), or as fields of objects. Once allocated, they are initialized using `initobj`. However, the `newobj` instruction can be used to create a new instance of a value type on the stack, that can then be passed as an argument, stored in a local, and so on.</para> <para>`System.OutOfMemoryException` is thrown if there is insufficient memory to satisfy the request.</para> <para>`System.MissingMethodException` is thrown if a constructor method `ctor` with the indicated name, class and signature could not be found. This is typically detected when Microsoft Intermediate Language (MSIL) instructions are converted to native code, rather than at runtime.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">newobj <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.newobj</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>nop</name> <verb>nop</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Fills space if opcodes are patched. No meaningful operation is performed although a processing cycle can be consumed.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 00 | nop |</para> <para>There is no stack transitional behavior defined for this instruction.</para> <para>The `nop` operation does nothing. It is intended to fill in space if opcodes are patched.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">nop</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.nop</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>not</name> <verb>not</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Computes the bitwise complement of the integer value on top of the stack and pushes the result onto the evaluation stack as the same type.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 66 | not |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value` is pushed onto the stack. 2. `value` is popped from the stack and its bitwise complement computed. 3. The result is pushed onto the stack. </para> <para>The `not` instruction computes the bitwise complement of an integer value and pushes the result onto the stack. The return type is the same as the operand type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">not</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.not</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>or</name> <verb>or</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Compute the bitwise complement of the two integer values on top of the stack and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 60 | or |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value1` is pushed onto the stack. 2. `value2` is pushed onto the stack. 3. `value2` and `value1` are popped from the stack and their bitwise OR computed. 4. The result is pushed onto the stack. </para> <para>The `or` instruction computes the bitwise OR of two values atop the stack, pushing the result onto the stack.</para> <para>`or` is an integer-specific operation.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">or</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.or</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>pop</name> <verb>pop</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Removes the value currently on top of the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 26 | pop |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The top value is popped from the stack. </para> <para>The `pop` instruction removes the top element from the stack.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">pop</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.pop</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>readonly.</name> <verb>readonly.</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies that the subsequent array address operation performs no type check at run time, and that it returns a managed pointer whose mutability is restricted.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft intermediate language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 1E | readonly. |</para> <para>This prefix can only appear immediately preceding the `ldelema` instruction and calls to the special `Address` method on arrays. Its effect on the subsequent operation is twofold:</para> <para>1. At run time, no type check operation is performed. Note that there is normally an implicit type check for the `ldelema` and `stelem` instructions when used on reference type arrays. There is never a run-time type check for value classes, so `readonly` is a no-op in that case. 2. The verifier treats the result of the address-of operation as a managed pointer with restricted mutability. </para> <para>The pointer is said to have restricted mutability because the defining type controls whether the value can be mutated. For value classes that expose no public fields or methods that update the value in place, the pointer is read-only (hence the name of the prefix). In particular, the classes representing primitive types (for example, System.Int32) do not expose mutators and thus are read-only.</para> <para>A managed pointer restricted in this fashion can be used only in the following ways:</para> <para>- As the `object` parameter for the `ldfld`, `ldflda`, `stfld`, `call`, or`constrained. callvirt` instructions. - As the `pointer` parameter to the `ldobj` instruction or to one of the `ldind` instructions. - As the `source` parameter to the `cpobj` instruction. </para> <para>All other operations disallowed, including the `stobj`, `initobj`, or `mkrefany` operations, or any of the `stind` instructions.</para> <para>The purpose of the `readonly.` prefix is to avoid a type check when fetching an element from an array in generic code. For example, the expression `arr[i].m()`, where the element type of the array `arr` is a generic type that has been constrained to have an interface with method `m`, might compile to the following MSIL.</para> <para>```cil ldloc arr ldloc i readonly. ldelema !0 // Loads the pointer to the object. … // Load the arguments to the call. constrained. !0 callvirt m ```</para> <para>Without the `readonly.` prefix, the `ldelema` instruction would perform a type check in the case where !0 was a reference type. Not only is this type check inefficient, but it is semantically incorrect. The type check for `ldelema` is an exact match, which is too strong. If the array held subclasses of type !0, the code above would fail the type check.</para> <para>The address of the array element is fetched, instead of the element itself, in order to have a handle for `arr[i]` that works for both value types and reference types, and thus can be passed to the `constrained callvirt` instruction.</para> <para>In general it would be unsafe to skip the run-time check if the array held elements of a reference type. To be safe, it is necessary to ensure that no modifications to the array are made through this pointer. The verifier rules ensure this. The restricted managed pointer can be passed as the object of instance method calls, so it is not strictly speaking read-only for value types, but there is no type safety problem for value types.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">readonly</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.readonly</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>refanytype</name> <verb>refanytype</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Retrieves the type token embedded in a typed reference.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 1D | refanytype |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value type reference is pushed onto the stack. 2. The typed reference is popped from the stack and its corresponding type token retrieved. 3. The type token is pushed onto the stack. </para> <para>A typed reference contains a type token and an address to an object instance.</para> <para>The `refanytype` instruction retrieves the type token embedded in the typed reference. See the `mkrefany` instruction for information on creating typed references.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">refanytype</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.refanytype</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>refanyval</name> <verb>refanyval</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Retrieves the address (type `&`) embedded in a typed reference.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ---------------- | | C2 < `T` > | refanyval `type` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value type reference is pushed onto the stack. 2. The typed reference is popped from the stack and the corresponding address retrieved. 3. The address is pushed onto the stack. </para> <para>A typed reference contains a type token and an address to an object instance.</para> <para>The `refanyval` instruction retrieves the address embedded in the a typed reference. The type embedded in the typed reference supplied on the stack must match the type specified by `type` (a metadata token, either a `typedef` or a `typeref`). See the `mkrefany` instruction for related content.</para> <para>`System.InvalidCastException` is thrown if `type` is not identical to the type stored in the type reference (in this case, `type` is the class supplied to the `mkrefany` instruction that constructed said typed reference).</para> <para>`System.TypeLoadException` is thrown if `type` cannot be found.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">refanyval <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.refanyval</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>rem</name> <verb>rem</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Divides two values and pushes the remainder onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 5D | rem |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A `value1` is pushed onto the stack. 2. `value2` is pushed onto the stack. 3. `value2` and `value1` are popped from the stack and the remainder of `value1` `div` `value2` computed. 4. The result is pushed onto the stack. </para> <para>`result` = `value1` `rem` `value2` satisfies the following conditions:</para> <para>`result` = `value1` - `value2` `×` (`value1` `div` `value2`), and:</para> <para>0 = | `result` | < | `value2` |, sign(`result`) = sign(`value1`), where `div` is the division instruction that truncates towards zero.</para> <para>If `value2` is zero or `value1` is infinity the result is NaN. If `value2` is infinity, the result is `value1` (negated for `-infinity`).</para> <para>Integral operations throw `System.DivideByZeroException` if `value2` is zero.</para> <para>Note that on the Intel-based platforms an `System.OverflowException` is thrown when computing (minint `rem` -1).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">rem</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.rem</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>rem.un</name> <verb>rem.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Divides two unsigned values and pushes the remainder onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 5E | rem.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value1` is pushed onto the stack. 2. `value2` is pushed onto the stack. 3. `value2` and `value1` are popped from the stack and the remainder of `value1` `div` `value2` computed. 4. The result is pushed onto the stack. </para> <para>`result` = `value1` `rem.un` `value2` satisfies the following conditions:</para> <para>`result` = `value1` - `value2` x(`value1` `div.un` `value2`), and:</para> <para>0 = `result` < `value2`, where `div.un` is the unsigned division instruction.</para> <para>The `rem.un` instruction computes `result` and pushes it on the stack. `Rem.un` treats its arguments as unsigned integers, while `rem` treats them as signed integers.</para> <para>`rem.un` is unspecified for floating-point numbers.</para> <para>Integral operations throw `System.DivideByZeroException` if `value2` is zero.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">rem.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.rem_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>ret</name> <verb>ret</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Returns from the current method, pushing a return value (if present) from the callee's evaluation stack onto the caller's evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 2A | ret |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The return value is popped from the callee evaluation stack. 2. The return value obtained in step 1 is pushed onto the caller evaluation stack. </para> <para>If the return value is not present on the callee evaluation stack, no value is returned (no stack transition behaviors for either the callee or caller method).</para> <para>The type of the return value, if any, of the current method determines the type of value to be fetched from the top of the stack and copied onto the stack of the method that called the current method. The evaluation stack for the current method must be empty except for the value to be returned.</para> <para>The `ret` instruction cannot be used to transfer control out of a`try`, `filter`, `catch`, or `finally` block. From within a `try` or `catch`, use the `leave` instruction with a destination of a `ret` instruction that is outside all enclosing exception blocks. Because the `filter` and `finally` blocks are logically part of exception handling and not the method in which their code is embedded, correctly generated Microsoft Intermediate Language (MSIL) instructions do not perform a method return from within a `filter` or `finally`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">ret</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.ret</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>rethrow</name> <verb>rethrow</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Rethrows the current exception.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 1A | rethrow |</para> <para>No stack transition behavior is defined for this instruction.</para> <para>The `rethrow` instruction is only permitted within the body of a `catch` handler. It throws the same exception that was caught by this handler.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">rethrow</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.rethrow</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>shl</name> <verb>shl</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Shifts an integer value to the left (in zeroes) by a specified number of bits, pushing the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 62 | shl |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is pushed onto the stack. 2. The amount of bits to be shifted is pushed onto the stack. 3. The number of bits to be shifted and the value are popped from the stack; the value is shifted left by the specified number of bits. 4. The result is pushed onto the stack. </para> <para>The `shl` instruction shifts the value (type `int32`, `int64` or `native int`) left by the specified number of bits. The number of bits is a value of type `int32` or `native int`. The return value is unspecified if the number of bits to be shifted is greater than or equal to the width (in bits) of the supplied value.</para> <para>`shl` inserts a zero bit in the lowest position on each shift.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">shl</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.shl</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>shr</name> <verb>shr</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Shifts an integer value (in sign) to the right by a specified number of bits, pushing the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 63 | shr |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is pushed onto the stack. 2. The amount of bits to be shifted is pushed onto the stack. 3. The number of bits to be shifted and the value are popped from the stack; the value is shifted right by the specified number of bits. 4. The result is pushed onto the stack. </para> <para>The `shr.un` instruction shifts the value (type `int32`, `int64` or `native int`) right by the specified number of bits. The number of bits is a value of type `int32` or `native int`. The return value is unspecified if the number of bits to be shifted is greater than or equal to the width (in bits) of the supplied value.</para> <para>`shr` replicates the high order bit on each shift, preserving the sign of the original value in the `result`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">shr</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.shr</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>shr.un</name> <verb>shr.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Shifts an unsigned integer value (in zeroes) to the right by a specified number of bits, pushing the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 64 | shr.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is pushed onto the stack. 2. The amount of bits to be shifted is pushed onto the stack. 3. The number of bits to be shifted and the value are popped from the stack; the value is shifted right by the specified number of bits. 4. The result is pushed onto the stack. </para> <para>The `shr.un` instruction shifts the value (type `int32`, `int64` or `native int`) right by the specified number of bits. The number of bits is a value of type `int32`, `int64` or `native int`. The return value is unspecified if the number of bits to be shifted is greater than or equal to the width (in bits) of the supplied value.</para> <para>`shr.un` inserts a zero bit in the highest position on each shift.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">shr.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.shr_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>sizeof</name> <verb>sizeof</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pushes the size, in bytes, of a supplied value type onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------- | ---------------- | | FE 1C < `T` > | sizeof `valType` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The size (in bytes) of the supplied value type (`valType`) is pushed onto the stack. </para> <para>`valType` must be a metadata token (a `typeref` or `typedef`) that specifies a value type, reference type, or generic type parameter.</para> <para>For a reference type, the size returned is the size of a reference value of the corresponding type (4 bytes on 32-bit systems), not the size of the data stored in objects referred to by the reference value. A generic type parameter can be used only in the body of the type or method that defines it. When that type or method is instantiated, the generic type parameter is replaced by a value type or reference type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">sizeof <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.sizeof</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>starg</name> <verb>starg</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores the value on top of the evaluation stack in the argument slot at a specified index.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------------------- | --------------- | | FE 0B < `unsigned int16` > | starg `num` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value currently on top of the stack is popped and placed in argument slot `num`. </para> <para>The `starg` instruction pops a value from the stack and places it in argument slot `num`. The type of the value must match the type of the argument, as specified in the current method's signature.</para> <para>For procedures that take a variable argument list, the `starg` instruction can be used only for the initial fixed arguments, not those in the variable part of the signature.</para> <para>Performing a store into arguments that hold an integer value smaller than 4 bytes long truncates the value as it moves from the stack to the argument. Floating-point values are rounded from their native size (type `F`) to the size associated with the argument.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">starg <int32></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">int32</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">int32</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.starg</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>starg.s</name> <verb>starg.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores the value on top of the evaluation stack in the argument slot at a specified index, short form.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------------------- | --------------- | | 10 < `unsigned int8` > | starg.s `num` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. The value currently on top of the stack is popped and placed in argument slot `num`. </para> <para>The `starg.s` instruction pops a value from the stack and places it in argument slot `num`. The type of the value must match the type of the argument, as specified in the current method's signature.</para> <para>The `starg.s` instruction provides an efficient encoding for use with the first 256 arguments.</para> <para>For procedures that take a variable argument list, the `starg.s` instruction can be used only for the initial fixed arguments, not those in the variable part of the signature.</para> <para>Performing a store into arguments that hold an integer value smaller than 4 bytes long truncates the value as it moves from the stack to the argument. Floating-point values are rounded from their native size (type `F`) to the size associated with the argument.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">starg.s <byte></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">byte</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">byte</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.starg_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stelem.i</name> <verb>stelem.i</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the array element at a given index with the `native int` value on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 9B | stelem.i |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array, `array`, is pushed onto the stack. 2. A valid index to an element in `array` is pushed onto the stack. 3. A value is pushed onto the stack. 4. The value, the index, and the array reference are popped from the stack; the value is put into the array element at the given index. </para> <para>The `stelem.i` instruction replaces the value of the element `index` in the one-dimensional array `array` with the `native int` value pushed onto the stack.</para> <para>Arrays are objects and hence represented by a value of type `O`. The index is type `native int`.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stelem.i</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stelem_i</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stelem.i1</name> <verb>stelem.i1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the array element at a given index with the `int8` value on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 9C | stelem.i1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array, `array`, is pushed onto the stack. 2. A valid index to an element in `array` is pushed onto the stack. 3. A value is pushed onto the stack. 4. The value, the index, and the array reference are popped from the stack; the value is put into the array element at the given index. </para> <para>The `stelem.i1` instruction replaces the value of the element `index` in the one-dimensional array `array` with the `int8` value pushed onto the stack.</para> <para>Arrays are objects and hence represented by a value of type `O`. The index is type `native int`.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stelem.i1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stelem_i1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stelem.i2</name> <verb>stelem.i2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the array element at a given index with the `int16` value on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 9D | stelem.i2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array, `array`, is pushed onto the stack. 2. A valid index to an element in `array` is pushed onto the stack. 3. A value is pushed onto the stack. 4. The value, the index, and the array reference are popped from the stack; the value is put into the array element at the given index. </para> <para>The `stelem.i2` instruction replaces the value of the element `index` in the one-dimensional array `array` with the `int16` value pushed onto the stack.</para> <para>Arrays are objects and hence represented by a value of type `O`. The index is type `native int`.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stelem.i2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stelem_i2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stelem.i4</name> <verb>stelem.i4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the array element at a given index with the `int32` value on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 9E | stelem.i4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array, `array`, is pushed onto the stack. 2. A valid index to an element in `array` is pushed onto the stack. 3. A value is pushed onto the stack. 4. The value, the index, and the array reference are popped from the stack; the value is put into the array element at the given index. </para> <para>The `stelem.i4` instruction replaces the value of the element `index` in the one-dimensional array `array` with the `int32` value pushed onto the stack.</para> <para>Arrays are objects and hence represented by a value of type `O`. The index is type `native int`.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stelem.i4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stelem_i4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stelem.i8</name> <verb>stelem.i8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the array element at a given index with the `int64` value on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 9F | stelem.i8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array, `array`, is pushed onto the stack. 2. A valid index to an element in `array` is pushed onto the stack. 3. A value is pushed onto the stack. 4. The value, the index, and the array reference are popped from the stack; the value is put into the array element at the given index. </para> <para>The `stelem.i8` instruction replaces the value of the element `index` in the one-dimensional array `array` with the `int64` value pushed onto the stack.</para> <para>Arrays are objects and hence represented by a value of type `O`. The index is type `native int`.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stelem.i8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stelem_i8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stelem</name> <verb>stelem</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the array element at a given index with the value on the evaluation stack, whose type is specified in the instruction.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft intermediate language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ---------------- | | A4 < `T` > | stelem `typeTok` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array, `array`, is pushed onto the stack. 2. An index value, `index`, to an element in `array` is pushed onto the stack. 3. A value of the type specified in the instruction is pushed onto the stack. 4. The value, the index, and the array reference are popped from the stack; the value is put into the array element at the given index. </para> <para>The `stelem` instruction replaces the value of the element at the supplied zero-based index in the one-dimensional array `array` with the value. The value has the type specified by the token `typeTok` in the instruction.</para> <para>Arrays are objects, and hence represented by a value of type `O`. The index is type `native int`.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stelem <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stelem</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stelem.r4</name> <verb>stelem.r4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the array element at a given index with the `float32` value on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | A0 | stelem.r4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array, `array`, is pushed onto the stack. 2. A valid index to an element in `array` is pushed onto the stack. 3. A value is pushed onto the stack. 4. The value, the index, and the array reference are popped from the stack; the value is put into the array element at the given index. </para> <para>The `stelem.r4` instruction replaces the value of the element `index` in the one-dimensional array `array` with the `float32` value pushed onto the stack.</para> <para>Arrays are objects and hence represented by a value of type `O`. The index is type `native int`.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stelem.r4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stelem_r4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stelem.r8</name> <verb>stelem.r8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the array element at a given index with the `float64` value on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | A1 | stelem.r8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array, `array`, is pushed onto the stack. 2. A valid index to an element in `array` is pushed onto the stack. 3. A value is pushed onto the stack. 4. The value, the index, and the array reference are popped from the stack; the value is put into the array element at the given index. </para> <para>The `stelem.r8` instruction replaces the value of the element `index` in the one-dimensional array `array` with the `float64` value pushed onto the stack.</para> <para>Arrays are objects and hence represented by a value of type `O`. The index is type `native int`.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stelem.r8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stelem_r8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stelem.ref</name> <verb>stelem.ref</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the array element at a given index with the object ref value (type `O`) on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | A2 | stelem.ref |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference to an array, `array`, is pushed onto the stack. 2. A valid index to an element in `array` is pushed onto the stack. 3. A value is pushed onto the stack. 4. The value, the index, and the array reference are popped from the stack; the value is put into the array element at the given index. </para> <para>The `stelem.ref` instruction replaces the value of the element at the supplied index in the one-dimensional array `array` with the `ref` (type `O`) value pushed onto the stack.</para> <para>Arrays are objects and hence represented by a value of type `O`. The index is type `native int`.</para> <para>Note that `stelem.ref` implicitly casts the supplied value to the element type of `array` before assigning the value to the array element. This cast can fail, even for verified code. Thus the `stelem.ref` instruction can throw `System.InvalidCastException`. For one-dimensional arrays that aren't zero-based and for multidimensional arrays, the `System.Array` class provides a `System.Array.SetValue*` method.</para> <para>`System.NullReferenceException` is thrown if `array` is a null reference.</para> <para>`System.IndexOutOfRangeException` is thrown if `index` is negative, or larger than the bound of `array`.</para> <para>`System.ArrayTypeMismatchException` is thrown if `array` does not hold elements of the required type.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stelem.ref</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stelem_ref</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stfld</name> <verb>stfld</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the value stored in the field of an object reference or pointer with a new value.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 7D < `T` > | stfld `field` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference or pointer is pushed onto the stack. 2. A value is pushed onto the stack. 3. The value and the object reference/pointer are popped from the stack; the value of `field` in the object is replaced with the supplied value. </para> <para>The `stfld` instruction replaces the value of a field of an object (type `O`) or via a pointer (type `native int`, `&`, or `*`) with a given value. `Field` is a metadata token that refers to a field member reference. The `stfld` instruction can have a prefix of either or both of `unaligned.` and `volatile.`.</para> <para>`System.NullReferenceException` is thrown if the object reference or pointer is a null reference and the field isn't static.</para> <para>`System.MissingFieldException` is thrown if `field` is not found in the metadata. This is typically checked when the Microsoft Intermediate Language (MSIL) instruction is converted to native code, not at runtime.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stfld <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stfld</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stind.i</name> <verb>stind.i</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores a value of type `native int` at a supplied address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | DF | stind.i |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. A value is pushed onto the stack. 3. The value and the address are popped from the stack; the value is stored at the address. </para> <para>The `stind.i` instruction stores a `native int` value at the supplied address (type `native int`, `*`, or `&`).</para> <para>Type safe operation requires that the `stind.i` instruction be used in a manner consistent with the type of the pointer. The operation of the `stind.i` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` is thrown if `addr` is not naturally aligned for the argument type implied by the instruction suffix.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stind.i</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stind_i</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stind.i1</name> <verb>stind.i1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores a value of type `int8` at a supplied address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 52 | stind.i1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. A value is pushed onto the stack. 3. The value and the address are popped from the stack; the value is stored at the address. </para> <para>The `stind.i1` instruction stores an `int8` value at the supplied address (type `native int`, `*`, or `&`).</para> <para>Type safe operation requires that the `stind.i1` instruction be used in a manner consistent with the type of the pointer. The operation of the `stind.i1` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` is thrown if `addr` is not naturally aligned for the argument type implied by the instruction suffix.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stind.i1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stind_i1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stind.i2</name> <verb>stind.i2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores a value of type `int16` at a supplied address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 53 | stind.i2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. A value is pushed onto the stack. 3. The value and the address are popped from the stack; the value is stored at the address. </para> <para>The `stind.i2` instruction stores an `int16` value at the supplied address (type `native int`, `*`, or `&`).</para> <para>Type safe operation requires that the `stind.2i` instruction be used in a manner consistent with the type of the pointer. The operation of the `stind.i2` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` is thrown if `addr` is not naturally aligned for the argument type implied by the instruction suffix.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stind.i2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stind_i2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stind.i4</name> <verb>stind.i4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores a value of type `int32` at a supplied address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 54 | stind.i4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. A value is pushed onto the stack. 3. The value and the address are popped from the stack; the value is stored at the address. </para> <para>The `stind.i4` instruction stores an `int32` value at the supplied address (type `native int`, `*`, or `&`).</para> <para>Type safe operation requires that the `stind.i4` instruction be used in a manner consistent with the type of the pointer. The operation of the `stind.i4` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` is thrown if `addr` is not naturally aligned for the argument type implied by the instruction suffix.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stind.i4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stind_i4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stind.i8</name> <verb>stind.i8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores a value of type `int64` at a supplied address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 55 | stind.i8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. A value is pushed onto the stack. 3. The value and the address are popped from the stack; the value is stored at the address. </para> <para>The `stind.i8` instruction stores an `int64` value at the supplied address (type `native int`, `*`, or `&`).</para> <para>Type safe operation requires that the `stind.i8` instruction be used in a manner consistent with the type of the pointer. The operation of the `stind.i` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` is thrown if `addr` is not naturally aligned for the argument type implied by the instruction suffix.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stind.i8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stind_i8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stind.r4</name> <verb>stind.r4</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores a value of type `float32` at a supplied address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 56 | stind.r4 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. A value is pushed onto the stack. 3. The value and the address are popped from the stack; the value is stored at the address. </para> <para>The `stind.r4` instruction stores a `float32` value at the supplied address (type `native int`, `*`, or `&`).</para> <para>Type safe operation requires that the `stind.r4` instruction be used in a manner consistent with the type of the pointer. The operation of the `stind.r4` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` is thrown if `addr` is not naturally aligned for the argument type implied by the instruction suffix.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stind.r4</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stind_r4</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stind.r8</name> <verb>stind.r8</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores a value of type `float64` at a supplied address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 57 | stind.r8 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. A value is pushed onto the stack. 3. The value and the address are popped from the stack; the value is stored at the address. </para> <para>The `stind.r8` instruction stores a `float64` value at the supplied address (type `native int`, `*`, or `&`).</para> <para>Type safe operation requires that the `stind.r8` instruction be used in a manner consistent with the type of the pointer. The operation of the `stind.r8` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` is thrown if `addr` is not naturally aligned for the argument type implied by the instruction suffix.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stind.r8</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stind_r8</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stind.ref</name> <verb>stind.ref</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Stores a object reference value at a supplied address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 51 | stind.ref |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. A value is pushed onto the stack. 3. The value and the address are popped from the stack; the value is stored at the address. </para> <para>The `stind.ref` instruction stores an object reference value at the supplied address (type `native int`, `*`, or `&`).</para> <para>Type safe operation requires that the `stind.ref` instruction be used in a manner consistent with the type of the pointer. The operation of the `stind.ref` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.NullReferenceException` is thrown if `addr` is not naturally aligned for the argument type implied by the instruction suffix.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stind.ref</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stind_ref</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stloc.0</name> <verb>stloc.0</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pops the current value from the top of the evaluation stack and stores it in a the local variable list at index 0.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 0A | stloc.0 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is popped off of the stack and placed in the local variable indexed by 0. </para> <para>The `stloc.0` instruction pops the top value off the evaluation stack and moves it into the local variable indexed by 0. The type of the value must match the type of the local variable as specified in the current method's local signature.</para> <para>`stloc.0` is an especially efficient encoding for storing values in local variable 0.</para> <para>Storing into locals that hold an integer value smaller than 4 bytes long truncates the value as it moves from the stack to the local variable. Floating-point values are rounded from their native size (type `F`) to the size associated with the argument.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stloc.0</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stloc_0</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stloc.1</name> <verb>stloc.1</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pops the current value from the top of the evaluation stack and stores it in a the local variable list at index 1.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 0B | stloc.1 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is popped off of the stack and placed in the local variable indexed by 1. </para> <para>The `stloc.1` instruction pops the top value off the evaluation stack and moves it into the local variable indexed by 1. The type of the value must match the type of the local variable as specified in the current method's local signature.</para> <para>`stloc.1` is an especially efficient encoding for storing values in local variable 1.</para> <para>Storing into locals that hold an integer value smaller than 4 bytes long truncates the value as it moves from the stack to the local variable. Floating-point values are rounded from their native size (type `F`) to the size associated with the argument.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stloc.1</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stloc_1</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stloc.2</name> <verb>stloc.2</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pops the current value from the top of the evaluation stack and stores it in a the local variable list at index 2.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 0C | stloc.2 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is popped off of the stack and placed in the local variable indexed by 2. </para> <para>The `stloc.2` instruction pops the top value off the evaluation stack and moves it into the local variable indexed by 2. The type of the value must match the type of the local variable as specified in the current method's local signature.</para> <para>`stloc.2` is an especially efficient encoding for storing values in local variable 2.</para> <para>Storing into locals that hold an integer value smaller than 4 bytes long truncates the value as it moves from the stack to the local variable. Floating-point values are rounded from their native size (type `F`) to the size associated with the argument.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stloc.2</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stloc_2</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stloc.3</name> <verb>stloc.3</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pops the current value from the top of the evaluation stack and stores it in a the local variable list at index 3.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 0D | stloc.3 |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is popped off of the stack and placed in the local variable indexed by 3. </para> <para>The `stloc.3` instruction pops the top value off the evaluation stack and moves it into the local variable indexed by 3. The type of the value must match the type of the local variable as specified in the current method's local signature.</para> <para>`stloc.3` is an especially efficient encoding for storing values in local variable 3.</para> <para>Storing into locals that hold an integer value smaller than 4 bytes long truncates the value as it moves from the stack to the local variable. Floating-point values are rounded from their native size (type `F`) to the size associated with the argument.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stloc.3</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stloc_3</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stloc.auto</name> <verb>stloc.auto</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pops the current value from the top of the evaluation stack and stores it in the local variable list at the index corresponding to the specified variable expression.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The `stloc.auto` instruction is a meta instruction specific to the `ILAssembler` PowerShell module. By passing a variable expression (e.g. `$varName`) that corresponds with a local defined in the `.locals` directive, this instruction will be replaced with the most appropriate `stloc*` instruction.</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is popped off of the stack and placed in specified local variable. </para> <para>The `stloc.auto` instruction pops the top value off the evaluation stack and moves it into the specified local variable. The type of the value must match the type of the local variable as specified in the current method's local signature.</para> <para>Storing into locals that hold an integer value smaller than 4 bytes long truncates the value as it moves from the stack to the local variable. Floating-point values are rounded from their native size (type `F`) to the size associated with the argument.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stloc.auto <psvariable></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">variable</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target variable location.</para> </Description> <parameterValue required="true" variableLength="false">int32</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">int32</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://github.com/SeeminglyScience/ILAssembler/blob/master/docs/en-US/stloc.auto.md</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stloc</name> <verb>stloc</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pops the current value from the top of the evaluation stack and stores it in a the local variable list at a specified index.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------------------- | --------------- | | FE 0E < `unsigned int16` > | stloc `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is popped off of the stack and placed in local variable `index`. </para> <para>The `stloc` instruction pops the top value off the evaluation stack and moves it into local variable number `index`, where local variables are numbered 0 onwards. The type of the value must match the type of the local variable as specified in the current method's local signature.</para> <para>Storing into locals that hold an integer value smaller than 4 bytes long truncates the value as it moves from the stack to the local variable. Floating-point values are rounded from their native size (type `F`) to the size associated with the argument.</para> <para>Correct Microsoft Intermediate Language (MSIL) instructions require that `index` be a valid local index. For the `stloc` instruction, `index` must lie in the range 0 to 65534 inclusive (specifically, 65535 is not valid). The reason for excluding 65535 is pragmatic: likely implementations will use a 2-byte integer to track both a local's index, as well as the total number of locals for a given method. If an index of 65535 had been made valid, it would require a wider integer to track the number of locals in such a method.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stloc <int32></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">int32</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">int32</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stloc</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stloc.s</name> <verb>stloc.s</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Pops the current value from the top of the evaluation stack and stores it in a the local variable list at `index` (short form).</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------------------- | --------------- | | 13 < `unsigned int8` > | stloc.s `index` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is popped off of the stack and placed in local variable `index`. </para> <para>The `stloc.s` instruction pops the top value off the evaluation stack and moves it into local variable number `index`, where local variables are numbered 0 onwards. The type of the value must match the type of the local variable as specified in the current method's local signature.</para> <para>The `stloc.s` instruction provides an efficient encoding for local variables 0 through 255.</para> <para>Storing into locals that hold an integer value smaller than 4 bytes long truncates the value as it moves from the stack to the local variable. Floating-point values are rounded from their native size (type `F`) to the size associated with the argument.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stloc.s <byte></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">index</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the index to load.</para> </Description> <parameterValue required="true" variableLength="false">byte</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">byte</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stloc_s</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stobj</name> <verb>stobj</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Copies a value of a specified type from the evaluation stack into a supplied memory address.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 81 < `T` > | stobj `class` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. 2. A value type object of type `class` is pushed onto the stack. 3. The object and the address are popped from the stack; the value type object is stored at the address. </para> <para>The `stobj` instruction copies the value type object into the address specified by the address (a pointer of type `native int`, `*`, or `&`). The number of bytes copied depends on the size of the class represented by `class`, a metadata token representing a value type.</para> <para>The operation of the `stobj` instruction can be altered by an immediately preceding `volatile.` or `unaligned.` prefix instruction.</para> <para>`System.TypeLoadException` is thrown if class cannot be found. This is typically detected when Microsoft Intermediate Language (MSIL) instructions are converted to native code rather than at run time.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stobj <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stobj</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>stsfld</name> <verb>stsfld</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Replaces the value of a static field with a value from the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 80 < `T` > | stsfld `field` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is pushed onto the stack. 2. A value is popped from the stack and stored in `field`. </para> <para>The `stsfld` instruction replaces the value of a static field with a value from the stack. `field` is a metadata token that must refer to a static field member.</para> <para>The `stsfld` instruction may be prefixed by `volatile.`.</para> <para>`System.MissingFieldException` is thrown if field is not found in the metadata. This is typically checked when Microsoft Intermediate Language (MSIL) instructions are converted to native code, not at run time.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">stsfld <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.stsfld</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>sub</name> <verb>sub</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Subtracts one value from another and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 59 | sub |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value1` is pushed onto the stack. 2. `value2` is pushed onto the stack. 3. `value2` and `value1` are popped from the stack; `value2` is subtracted from `value1`. 4. The result is pushed onto the stack. </para> <para>Overflow is not detected for integer operations (for proper overflow handling, see `sub.ovf`).</para> <para>Integer subtraction wraps, rather than saturates. For example: assuming 8-bit integers, where `value1` is set to 0 and `value2` is set to 1, the "wrapped" result will be 255.</para> <para>Floating-point overflow returns `+inf` (`PositiveInfinity`) or `-inf` (`NegativeInfinity`).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">sub</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.sub</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>sub.ovf</name> <verb>sub.ovf</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Subtracts one integer value from another, performs an overflow check, and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | DA | sub.ovf |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value1` is pushed onto the stack. 2. `value2` is pushed onto the stack. 3. `value2` and `value1` are popped from the stack; `value2` is subtracted from `value1` with a check for overflow. 4. The result is pushed onto the stack. </para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> <para>This operation is performed on signed integers; for floating-point values, use `sub`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">sub.ovf</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.sub_ovf</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>sub.ovf.un</name> <verb>sub.ovf.un</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Subtracts one unsigned integer value from another, performs an overflow check, and pushes the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | DB | sub.ovf.un |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value1` is pushed onto the stack. 2. `value2` is pushed onto the stack. 3. `value2` and `value1` are popped from the stack; `value2` is subtracted from `value1` with a check for overflow. 4. The result is pushed onto the stack. </para> <para>`System.OverflowException` is thrown if the result can not be represented in the result type.</para> <para>This operation is performed on signed integers; for floating-point values, use `sub`.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">sub.ovf.un</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.sub_ovf_un</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>switch</name> <verb>switch</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Implements a jump table.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | -------------------------------------------------- | -------------------------------- | | 45 < `unsigned int32` > < `int32` >... < `int32` > | switch (`N`, `t1`, `t2`... `tN`) |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. A value is pushed onto the stack. 2. The value is popped off the stack and execution is transferred to the instruction at the offset indexed by the value, where the value is less than `N`. </para> <para>The `switch` instruction implements a jump table. The format of the instruction is an `unsigned int32` representing the number of targets `N`, followed by `N` int32 values specifying jump targets. These targets are represented as offsets (positive or negative) from the beginning of the instruction following this `switch` instruction.</para> <para>The `switch` instruction pops a value off the stack and compares it, as an unsigned integer, to `N`. If value is less than `N`, execution is transferred to the target indexed by value, where targets are numbered from 0 (for example, a value of 0 takes the first target, a value of 1 takes the second target, and so on). If the value is greater than or equal to `N`, execution continues at the next instruction (fall through).</para> <para>If the target instruction has one or more prefix codes, control can only be transferred to the first of these prefixes.</para> <para>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 leave instruction instead).</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">switch <branch_name[]></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branchs</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies a list of labels to transfer execution to should their index match the value popped off the stack.</para> </Description> <parameterValue required="true" variableLength="false">branch_name[]</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">branch_name[]</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.switch</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>tailcall</name> <verb>tailcall</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Performs a postfixed method call instruction such that the current method's stack frame is removed before the actual call instruction is executed.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 14 | tail. |</para> <para>There is no stack transition behavior defined for this instruction.</para> <para>The `tail` prefix instruction must immediately precede a `call`, `calli`, or `callvirt` instruction. It indicates that the current method's stack frame should be removed before the call instruction is executed. It also implies that the value returned from the following call is also the value returned by the current method, and the call can therefore be converted into a cross-method jump.</para> <para>The stack must be empty except for the arguments being transferred by the following call. The instruction following the call instruction must be a ret. Thus the only valid code sequence is `tail. call` (or `calli` or `callvirt`). Correct Microsoft Intermediate Language (MSIL) instructions must not branch to the `call` instruction, but they may branch to the subsequent `ret`.</para> <para>The current frame cannot be discarded when control is transferred from untrusted code to trusted code, since this would jeopardize code identity security. The .NET Framework security checks can therefore cause the `tail` to be ignored, leaving a standard `call` instruction. Similarly, in order to allow the exit of a synchronized region to occur after the call returns, the `tail` prefix is ignored when used to exit a method that is marked synchronized.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">tailcall</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.tailcall</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>throw</name> <verb>throw</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Throws the exception object currently on the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 7A | throw |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference (to an exception) is pushed onto the stack. 2. The object reference is popped from the stack and the exception thrown. </para> <para>The `throw` instruction throws the exception object (type `O`) currently on the stack.</para> <para>`System.NullReferenceException` is thrown if the object reference is a null reference.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">throw</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.throw</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>unaligned.</name> <verb>unaligned.</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Indicates that an address currently atop the evaluation stack might not be aligned to the natural size of the immediately following `ldind`, `stind`, `ldfld`, `stfld`, `ldobj`, `stobj`, `initblk`, or `cpblk` instruction.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------------------------- | ---------------------- | | FE 12 < `unsigned int8` > | unaligned. `alignment` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. </para> <para>`Unaligned` specifies that the address (an unmanaged pointer, `native int`) on the stack might not be aligned to the natural size of the immediately following `ldind`, `stind`, `ldfld`, `stfld`, `ldobj`, `stobj`, `initblk`, or `cpblk` instruction. That is, for a `ldind.i4` instruction the alignment of the address may not be to a 4-byte boundary. For `initblk` and `cpblk` the default alignment is architecture dependent (4-byte on 32-bit CPUs, 8-byte on 64-bit CPUs). Code generators that do not restrict their output to a 32-bit word size must use `unaligned` if the alignment is not known at compile time to be 8-byte.</para> <para>The value of alignment must be 1, 2, or 4 and means that the generated code should assume that the address is byte, double-byte, or quad-byte aligned, respectively. Note that transient pointers (type `*`) are always aligned.</para> <para>While the alignment for a `cpblk` instruction would logically require two numbers (one for the source and one for the destination), there is no noticeable impact on performance if only the lower number is specified.</para> <para>The `unaligned` and `volatile` prefixes can be combined in either order. They must immediately precede a `ldind`, `stind`, `ldfld`, `stfld`, `ldobj`, `stobj`, `initblk`, or `cpblk` instruction. Only the `volatile.` prefix is allowed for the `ldsfld` and `stsfld` instructions.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">unaligned. <1 | 2 | 4></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">alignment</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies that generated code should assume that the following address is byte, double-byte, or quad-byte aligned.</para> </Description> <parameterValue required="true" variableLength="false">1 | 2 | 4</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">1 | 2 | 4</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.unaligned</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>unbox.any</name> <verb>unbox.any</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the boxed representation of a type specified in the instruction to its unboxed form.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft intermediate language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | ------------------- | | A5 < `T` > | unbox.any `typeTok` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference `obj` is pushed onto the stack. 2. The object reference is popped from the stack and unboxed to the type specified in the instruction. 3. The resulting object reference or value type is pushed onto the stack. </para> <para>When applied to the boxed form of a value type, the `unbox.any` instruction extracts the value contained within `obj` (of type `O`), and is therefore equivalent to `unbox` followed by `ldobj`.</para> <para>When applied to a reference type, the `unbox.any` instruction has the same effect as `castclass` `typeTok`.</para> <para>If the operand `typeTok` is a generic type parameter, then the runtime behavior is determined by the type that is specified for that generic type parameter.</para> <para>`System.InvalidCastException` is thrown if `obj` is not a boxed type.</para> <para>`System.NullReferenceException` is thrown if `obj` is a null reference.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">unbox.any <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.unbox_any</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>unbox</name> <verb>unbox</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Converts the boxed representation of a value type to its unboxed form.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ---------- | --------------- | | 79 < `T` > | unbox `valType` |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An object reference is pushed onto the stack. 2. The object reference is popped from the stack and unboxed to a value type pointer. 3. The value type pointer is pushed onto the stack. </para> <para>A value type has two separate representations within the Common Language Infrastructure (CLI):</para> <para>- A 'raw' form used when a value type is embedded within another object. - A 'boxed' form, where the data in the value type is wrapped (boxed) into an object so it can exist as an independent entity. </para> <para>The `unbox` instruction converts the object reference (type `O`), the boxed representation of a value type, to a value type pointer (a managed pointer, type `&`), its unboxed form. The supplied value type (`valType`) is a metadata token indicating the type of value type contained within the boxed object.</para> <para>Unlike `box`, which is required to make a copy of a value type for use in the object, `unbox` is not required to copy the value type from the object. Typically it simply computes the address of the value type that is already present inside of the boxed object.</para> <para>`System.InvalidCastException` is thrown if the object is not boxed as `valType`.</para> <para>`System.NullReferenceException` is thrown if the object reference is a null reference.</para> <para>`System.TypeLoadException` is thrown if the value type `valType` cannot be found. This is typically detected when Microsoft Intermediate Language (MSIL) instructions are converted to native code, rather than at runtime.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">unbox <signature></name> </syntaxItem> </syntax> <parameters> <parameter required="true" variableLength="false" globbing="false" pipelineInput="false" position="1" aliases=""> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <Description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies the target signature.</para> </Description> <parameterValue required="true" variableLength="false">signature</parameterValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">signature</name> <uri xmlns="http://schemas.microsoft.com/maml/2004/10" /> </type> <defaultValue xmlns="http://schemas.microsoft.com/maml/dev/2004/10">None</defaultValue> </parameter> </parameters> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.unbox</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>volatile.</name> <verb>volatile.</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Specifies that an address currently atop the evaluation stack might be volatile, and the results of reading that location cannot be cached or that multiple stores to that location cannot be suppressed.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | FE 13 | volatile. |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. An address is pushed onto the stack. </para> <para>`volatile.`. specifies that the address is a volatile address (that is, it can be referenced externally to the current thread of execution) and the results of reading that location cannot be cached or that multiple stores to that location cannot be suppressed. Marking an access as `volatile.` affects only that single access; other accesses to the same location must be marked separately. Access to volatile locations need not be performed atomically.</para> <para>The `unaligned.` and `volatile.` prefixes can be combined in either order. They must immediately precede a `ldind`, `stind`, `ldfld`, `stfld`, `ldobj`, `stobj`, `initblk`, or `cpblk` instruction. Only the `volatile.` prefix is allowed for the `ldsfld` and `stsfld` instructions.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">volatile.</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.volatile</uri> </navigationLink> </relatedLinks> </command> <command xmlns="http://schemas.microsoft.com/maml/dev/command/2004/10"> <details> <name>xor</name> <verb>xor</verb> <noun /> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>Computes the bitwise XOR of the top two values on the evaluation stack, pushing the result onto the evaluation stack.</para> </description> </details> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>The following table lists the instruction's hexadecimal and Microsoft Intermediate Language (MSIL) assembly format, along with a brief reference summary:</para> <para>| Format | Assembly Format | | ------ | --------------- | | 61 | xor |</para> <para>The stack transitional behavior, in sequential order, is:</para> <para>1. `value1` is pushed onto the stack. 2. `value2` is pushed onto the stack. 3. `value2` and `value1` are popped from the stack and their bitwise XOR computed. 4. The bitwise XOR of `value2` and `value1` is pushed onto the stack. </para> <para>The `xor` instruction computes the bitwise XOR of the top two values on the stack and leaves the result on the stack.</para> <para>`xor` is an integer-specific operation.</para> </description> <syntax> <syntaxItem> <name xmlns="http://schemas.microsoft.com/maml/2004/10">xor</name> </syntaxItem> </syntax> <parameters /> <inputTypes> <inputType> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </inputType> </inputTypes> <returnValues> <returnValue> <type xmlns="http://schemas.microsoft.com/maml/dev/2004/10"> <name xmlns="http://schemas.microsoft.com/maml/2004/10">None</name> </type> <description xmlns="http://schemas.microsoft.com/maml/2004/10"> <para>This function cannot be used with the pipeline.</para> </description> </returnValue> </returnValues> <alertSet xmlns="http://schemas.microsoft.com/maml/2004/10"> <alert> <para /> </alert> </alertSet> <examples /> <relatedLinks> <navigationLink xmlns="http://schemas.microsoft.com/maml/2004/10"> <linkText>Online Version:</linkText> <uri>https://docs.microsoft.com/en-us/dotnet/api/system.reflection.emit.opcodes.xor</uri> </navigationLink> </relatedLinks> </command> </helpItems> |