Shulou(Shulou.com)06/01 Report--

Name description

The name indicates that Add adds the two values and pushes the result onto the evaluation stack.

Ldelem.I1 loads elements of type int8 at the specified array index into the top of the evaluation stack as int32. Add.Ovf adds two integers, performs an overflow check, and pushes the result onto the evaluation stack.

Ldelem.I2 loads elements of type int16 at the specified array index into the top of the evaluation stack as int32. Add.Ovf.Un adds two unsigned integer values, performs an overflow check, and pushes the result onto the evaluation stack.

Ldelem.I4 loads elements of type int32 at the specified array index into the top of the evaluation stack as int32. And calculates the bitwise "and" of the two values and pushes the result onto the evaluation stack.

Ldelem.I8 loads elements of type int64 at the specified array index into the top of the evaluation stack as int64. Arglist returns an unmanaged pointer to the parameter list of the current method.

Ldelem.R4 loads elements of type float32 at the specified array index into the top of the evaluation stack as type F (floating point). Beq transfers control to the target instruction if the two values are equal.

Ldelem.R8 loads elements of type float64 at the specified array index into the top of the evaluation stack as type F (floating point). Beq.S transfers control to the target instruction (short format) if the two values are equal.

Ldelem.Ref loads the element containing the object reference at the specified array index into the top of the evaluation stack as an O type (object reference). Bge transfers control to the target instruction if the first value is greater than or equal to the second value.

Ldelem.U1 loads elements of type unsigned int8 at the specified array index into the top of the evaluation stack as int32. Bge.S transfers control to the target instruction (short format) if the first value is greater than or equal to the second value.

Ldelem.U2 loads elements of type unsigned int16 at the specified array index into the top of the evaluation stack as int32. Bge.Un transfers control to the target instruction if the first value is greater than the second value when comparing unsigned integer values or unsortable floating-point values.

Ldelem.U4 loads elements of type unsigned int32 at the specified array index into the top of the evaluation stack as int32. Bge.Un.S transfers control to the target instruction (short format) if the first value is greater than the second value when comparing unsigned integer values or unsortable floating-point values.

Ldelema loads the address of the array element at the specified array index as the & type (managed pointer) onto the top of the evaluation stack. Bgt transfers control to the target instruction if the first value is greater than the second value.

The value in the Ldfld lookup object that references the field currently on the evaluation stack. Bgt.S transfers control to the target instruction (short format) if the first value is greater than the second value.

The address of the Ldflda lookup object whose reference is currently on the evaluation stack. Bgt.Un transfers control to the target instruction if the first value is greater than the second value when comparing unsigned integer values or unsortable floating-point values.

Ldftn pushes an unmanaged pointer (of type native int) to native code that implements a specific method onto the evaluation stack. Bgt.Un.S transfers control to the target instruction (short format) if the first value is greater than the second value when comparing unsigned integer values or unsortable floating-point values.

Ldind.I loads values of type native int indirectly on the evaluation stack as native int. Ble transfers control to the target instruction if the first value is less than or equal to the second value.

Ldind.I1 loads values of type int8 indirectly on the evaluation stack as int32. Ble.S transfers control to the target instruction (short format) if the first value is less than or equal to the second value.

Ldind.I2 loads values of type int16 indirectly on the evaluation stack as int32. Ble.Un transfers control to the target instruction if the first value is less than or equal to the second value when comparing unsigned integer values or unsortable floating-point values.

Ldind.I4 loads values of type int32 indirectly on the evaluation stack as int32. Ble.Un.S transfers control to the target instruction (short format) if the first value is less than or equal to the second value when comparing unsigned integer values or unsortable floating-point values.

Ldind.I8 loads values of type int64 indirectly on the evaluation stack as int64. Blt transfers control to the target instruction if the first value is less than the second value.

Ldind.R4 loads the value of type float32 on the evaluation stack indirectly as an F (float) type. Blt.S transfers control to the target instruction (short format) if the first value is less than the second value.

Ldind.R8 loads the value of type float64 on the evaluation stack indirectly as an F (float) type. Blt.Un transfers control to the target instruction if the first value is less than the second value when comparing unsigned integer values or unsortable floating-point values.

Ldind.Ref loads object references indirectly on the evaluation stack as an O (object reference) type. Blt.Un.S transfers control to the target instruction (short format) if the first value is less than the second value when comparing unsigned integer values or unsortable floating-point values.

Ldind.U1 loads values of type unsigned int8 indirectly on the evaluation stack as int32. Bne.Un transfers control to the target instruction when two unsigned integer values or unsortable floating-point values are not equal.

Ldind.U2 loads values of type unsigned int16 indirectly on the evaluation stack as int32. Bne.Un.S transfers control to the target instruction (short format) when two unsigned integer values or unsortable floating-point values are not equal.

Ldind.U4 loads values of type unsigned int32 indirectly on the evaluation stack as int32. Box converts a value class to an object reference (O type).

Ldlen pushes the zero-based number of elements of an one-dimensional array onto the evaluation stack. Br transfers control to the target instruction unconditionally.

Ldloc loads the local variable at the specified index onto the evaluation stack. Br.S unconditionally transfers control to the target instruction (short format).

Ldloc.0 loads the local variable at index 0 onto the evaluation stack. Break signals the common language structure (CLI) to notify the debugger that a breakpoint has been hit.

Ldloc.1 loads the local variable at index 1 onto the evaluation stack. Brfalse transfers control to the target instruction if value is false, null reference (Nothing in Visual Basic), or zero.

Ldloc.2 loads the local variable at index 2 onto the evaluation stack. Brfalse.S transfers control to the target instruction if value is false, null reference, or zero.

Ldloc.3 loads the local variable at index 3 onto the evaluation stack. Brtrue transfers control to the target instruction if value is true, non-null, or non-zero.

Ldloc.S loads local variables at a specific index onto the evaluation stack (in short format). Brtrue.S transfers control to the target instruction (short format) if value is true, non-null, or non-zero.

Ldloca loads the address of a local variable at a specific index onto the evaluation stack. Call calls the method indicated by the passed method specifier.

Ldloca.S loads the address of the local variable at a specific index onto the evaluation stack (in short format). Calli invokes the method indicated on the evaluation stack (as a pointer to the entry point) through the parameters described by the calling convention.

Ldnull pushes a null reference (O type) onto the evaluation stack. Callvirt calls the late-bound method on the object and pushes the return value onto the evaluation stack.

Ldobj copies the value type object that the address points to to the top of the evaluation stack. Castclass attempts to convert the object passed by the reference to the specified class.

Ldsfld pushes the value of the static field onto the evaluation stack. Ceq compares two values. If the two values are equal, the integer value 1 (int32) is pushed onto the evaluation stack; otherwise, 0 (int32) is pushed onto the evaluation stack.

Ldsflda pushes the address of the static field onto the evaluation stack. Cgt compares two values. If the first value is greater than the second value, the integer value 1 (int32) is pushed onto the evaluation stack; otherwise, 0 (int32) is pushed onto the evaluation stack.

Ldstr pushes a new object reference to the string stored in the metadata. Cgt.Un compares two unsigned or unsortable values. If the first value is greater than the second value, the integer value 1 (int32) is pushed onto the evaluation stack; otherwise, 0 (int32) is pushed onto the evaluation stack.

Ldtoken converts the metadata token to its runtime representation and pushes it onto the evaluation stack. Ckfinite throws an ArithmeticException if the value is not finite.

Ldvirtftn pushes an unmanaged pointer (of type native int) to native code that implements a specific virtual method associated with the specified object onto the evaluation stack. Clt compares two values. If the first value is less than the second value, the integer value 1 (int32) is pushed onto the evaluation stack; otherwise, 0 (int32) is pushed onto the evaluation stack.

Leave exits the protected area of code and unconditionally transfers control to a specific target instruction. Clt.Un compares the unsigned or unsorted values value1 and value2. If value1 is less than value2, the integer value 1 (int32) is pushed onto the evaluation stack; otherwise, 0 (int32) is pushed onto the evaluation stack.

Leave.S exits the protected code area and unconditionally transfers control to the target instruction (abbreviated form). The type on which the Constrained constraint makes a virtual method call.

Localloc allocates a specific number of bytes from the local dynamic memory pool and pushes the address of the first allocated byte (transient pointer, * type) onto the computation stack. Conv.I converts the value at the top of the evaluation stack to native int.

Mkrefany pushes typed references to instances of a particular type onto the evaluation stack. Conv.I1 converts the value at the top of the evaluation stack to int8, and then extends (populates) it to int32.

Mul multiplies the two values and pushes the result onto the evaluation stack. Conv.I2 converts the value at the top of the evaluation stack to int16, and then extends (populates) it to int32.

Mul.Ovf multiplies two integer values, performs an overflow check, and pushes the result onto the evaluation stack. Conv.I4 converts the value at the top of the evaluation stack to int32.

Mul.Ovf.Un multiplies two unsigned integer values, performs an overflow check, and pushes the result onto the evaluation stack. Conv.I8 converts the value at the top of the evaluation stack to int64.

Neg inverts a value and pushes the result onto the evaluation stack. Conv.Ovf.I converts the signed value at the top of the evaluation stack to a signed native int and throws an OverflowException when it overflows.

Newarr pushes an object reference to a new zero-based one-dimensional array whose elements belong to a specific type onto the evaluation stack. Conv.Ovf.I.Un converts the unsigned value at the top of the evaluation stack to a signed native int and throws an OverflowException when it overflows.

Newobj creates a new object or instance of the value type and pushes the object reference (O type) onto the evaluation stack. Conv.Ovf.I1 converts the signed value at the top of the evaluation stack to a signed int8, extends it to int32, and throws an OverflowException when it overflows.

Nop fills the space if the opcode is patched. Although processing cycles may be consumed, no meaningful action is performed. Conv.Ovf.I1.Un converts the unsigned value at the top of the evaluation stack to a signed int8, extends it to int32, and throws an OverflowException when it overflows.

Not evaluates the bitwise complement of the integer value at the top of the stack and pushes the result onto the evaluation stack as the same type. Conv.Ovf.I2 converts the signed value at the top of the evaluation stack to a signed int16, extends it to int32, and throws an OverflowException when it overflows.

Or calculates the bitwise complement of the two integer values at the top of the stack and pushes the result onto the evaluation stack. Conv.Ovf.I2.Un converts the unsigned value at the top of the evaluation stack to a signed int16, extends it to int32, and throws an OverflowException when it overflows.

Pop removes the value currently at the top of the evaluation stack. Conv.Ovf.I4 converts the signed value at the top of the evaluation stack to a signed int32 and throws an OverflowException when it overflows.

Prefix1 infrastructure. This instruction is a reserved instruction. Conv.Ovf.I4.Un converts the unsigned value at the top of the evaluation stack to a signed int32 and throws an OverflowException when it overflows.

Prefix2 infrastructure. This instruction is a reserved instruction. Conv.Ovf.I8 converts the signed value at the top of the evaluation stack to a signed int64 and throws an OverflowException when it overflows.

Prefix3 infrastructure. This instruction is a reserved instruction. Conv.Ovf.I8.Un converts the unsigned value at the top of the evaluation stack to a signed int64 and throws an OverflowException when it overflows.

Prefix4 infrastructure. This instruction is a reserved instruction. Conv.Ovf.U converts the signed value at the top of the evaluation stack to unsigned native int and throws an OverflowException when it overflows.

Prefix5 infrastructure. This instruction is a reserved instruction. Conv.Ovf.U.Un converts the unsigned value at the top of the evaluation stack to unsigned native int and throws an OverflowException when it overflows.

Prefix6 infrastructure. This instruction is a reserved instruction. Conv.Ovf.U1 converts the signed value at the top of the evaluation stack to unsigned int8, extends it to int32, and throws an OverflowException in case of an overflow.

Prefix7 infrastructure. This instruction is a reserved instruction. Conv.Ovf.U1.Un converts the unsigned value at the top of the evaluation stack to unsigned int8, extends it to int32, and throws an OverflowException when it overflows.

Prefixref infrastructure. This instruction is a reserved instruction. Conv.Ovf.U2 converts the signed value at the top of the evaluation stack to unsigned int16, extends it to int32, and throws an OverflowException in case of an overflow.

Readonly specifies that subsequent array address operations do not perform type checking at run time and return managed pointers with limited variability. Conv.Ovf.U2.Un converts the unsigned value at the top of the evaluation stack to unsigned int16, extends it to int32, and throws an OverflowException when it overflows.

Refanytype retrieves type tags embedded in typed references. Conv.Ovf.U4 converts the signed value at the top of the evaluation stack to unsigned int32 and throws an OverflowException when it overflows.

Refanyval retrieves the address (& type) embedded in the typed reference. Conv.Ovf.U4.Un converts the unsigned value at the top of the evaluation stack to unsigned int32 and throws an OverflowException when it overflows.

Rem divides the two values and pushes the remainder onto the evaluation stack. Conv.Ovf.U8 converts the signed value at the top of the evaluation stack to unsigned int64 and throws an OverflowException when it overflows.

Rem.Un divides two unsigned values and pushes the remainder onto the evaluation stack. Conv.Ovf.U8.Un converts the unsigned value at the top of the evaluation stack to unsigned int64 and throws an OverflowException when it overflows.

Ret returns from the current method and pushes the return value, if any, from the caller's evaluation stack to the callee's evaluation stack. Conv.R.Un converts the unsigned integer value at the top of the evaluation stack to float32.

Rethrow throws the current exception again. Conv.R4 converts the value at the top of the evaluation stack to float32.

Shl shifts the integer value to the left (populated with zeros) by the specified number of bits and pushes the result onto the evaluation stack. Conv.R8 converts the value at the top of the evaluation stack to float64.

Shr shifts the integer value to the right (preserving the symbol) by the specified number of digits and pushes the result onto the evaluation stack. Conv.U converts the value at the top of the evaluation stack to unsigned native int and then extends it to native int.

Shr.Un shifts the unsigned integer value to the right (populated with zeros) by the specified number of bits and pushes the result onto the evaluation stack. Conv.U1 converts the value at the top of the evaluation stack to unsigned int8 and then extends it to int32.

Sizeof pushes the size of the supplied value type (in bytes) onto the evaluation stack. Conv.U2 converts the value at the top of the evaluation stack to unsigned int16 and then extends it to int32.

Starg stores the value at the top of the evaluation stack in the parameter slot at the specified index. Conv.U4 converts the value at the top of the evaluation stack to unsigned int32 and then extends it to int32.

Starg.S stores the value at the top of the evaluation stack at the specified index in the parameter slot (short format). Conv.U8 converts the value at the top of the evaluation stack to unsigned int64 and then extends it to int64.

Stelem replaces the array element at the given index with the value in the evaluation stack, whose type is specified in the instruction. Cpblk copies a specified number of bytes from the source to the destination address.

Stelem.I replaces the array element at the given index with the native int value on the evaluation stack. Cpobj copies the value type at the address of the object (type &, *, or native int) to the address of the target object (type &, *, or native int).

Stelem.I1 replaces the array element at the given index with the int8 value on the evaluation stack. Div divides two values and pushes the result onto the evaluation stack as a floating point (F type) or quotient (int32 type).

Stelem.I2 replaces the array element at the given index with the int16 value on the evaluation stack. Div.Un divides two unsigned integer values and pushes the result (int32) onto the evaluation stack.

Stelem.I4 replaces the array element at the given index with the int32 value on the evaluation stack. Dup copies the current topmost value on the evaluation stack and then pushes the copy onto the evaluation stack.

Stelem.I8 replaces the array element at the given index with the int64 value on the evaluation stack. Endfilter transfers control from the filter clause of the exception back to the common language structure (CLI) exception handler.

Stelem.R4 replaces the array element at the given index with the float32 value on the evaluation stack. Endfinally transfers control from the fault or finally clause of the exception block back to the common language structure (CLI) exception handler.

Stelem.R8 replaces the array element at the given index with the float64 value on the evaluation stack. Initblk initializes the specified block of memory at a specific address to a given size and initial value.

Stelem.Ref replaces the array element at a given index with the object ref value (O type) on the evaluation stack. Initobj initializes each field of the value type at the specified address to a null reference or 0 of the appropriate primitive type.

Stfld replaces the value stored in the field of the object reference or pointer with the new value. Isinst tests whether the object reference (O type) is an instance of a particular class.

Stind.I stores values of type native int at the address provided. Jmp exits the current method and jumps to the specified method.

Stind.I1 stores values of type int8 at the address provided. Ldarg loads parameters (referenced by the specified index value) onto the stack.

Stind.I2 stores values of type int16 at the address provided. Ldarg.0 loads the parameter with index 0 on the evaluation stack.

Stind.I4 stores values of type int32 at the address provided. Ldarg.1 loads the parameter with index 1 on the evaluation stack.

Stind.I8 stores values of type int64 at the address provided. Ldarg.2 loads the parameter with index 2 on the evaluation stack.

Stind.R4 stores values of type float32 at the address provided. Ldarg.3 loads the parameter with index 3 on the evaluation stack.

Stind.R8 stores values of type float64 at the address provided. Ldarg.S loads parameters (referenced by the specified short-format index) onto the evaluation stack.

Stind.Ref stores the object reference value at the address provided. Ldarga loads the parameter address onto the evaluation stack.

Stloc pops the current value from the top of the evaluation stack and stores it in the list of local variables at the specified index. Ldarga.S loads the parameter address on the evaluation stack in a short format.

Stloc.0 pops the current value from the top of the evaluation stack and stores it in the list of local variables at index 0. Ldc.I4 pushes the supplied value of type int32 as int32 onto the evaluation stack.

Stloc.1 pops the current value from the top of the evaluation stack and stores it in the list of local variables at index 1. Ldc.I4.0 pushes the integer value 0 as int32 onto the evaluation stack.

Stloc.2 pops the current value from the top of the evaluation stack and stores it in the list of local variables at index 2. Ldc.I4.1 pushes the integer value 1 as int32 onto the evaluation stack.

Stloc.3 pops the current value from the top of the evaluation stack and stores it in the list of local variables at index 3. Ldc.I4.2 pushes the integer value 2 as int32 onto the evaluation stack.

Stloc.S pops the current value from the top of the evaluation stack and stores it at index in the list of local variables (short format). Ldc.I4.3 pushes the integer value 3 as int32 onto the evaluation stack.

Stobj copies values of the specified type from the evaluation stack to the memory address provided. Ldc.I4.4 pushes the integer value 4 as int32 onto the evaluation stack.

Stsfld replaces the value of the static field with the value from the evaluation stack. Ldc.I4.5 pushes the integer value 5 as int32 onto the evaluation stack.

Sub subtracts a value from the other values and pushes the result onto the evaluation stack. Ldc.I4.6 pushes the integer value 6 as int32 onto the evaluation stack.

Sub.Ovf subtracts an integer value from another value, performs an overflow check, and pushes the result onto the evaluation stack. Ldc.I4.7 pushes the integer value 7 as int32 onto the evaluation stack.

Sub.Ovf.Un subtracts an unsigned integer value from another value, performs an overflow check, and pushes the result onto the evaluation stack. Ldc.I4.8 pushes the integer value 8 as int32 onto the evaluation stack.

Switch implements the jump table. Ldc.I4.M1 pushes the integer value-1 as int32 onto the evaluation stack.

Tailcall executes the suffixed method call instruction to remove the stack frame of the current method before the actual call instruction is executed. Ldc.I4.S pushes the supplied int8 value as int32 onto the evaluation stack (in short format).

Throw throws an exception object that is currently on the evaluation stack. Ldc.I8 pushes the supplied value of type int64 as int64 onto the evaluation stack.

Unaligned indicates that the address currently on the evaluation stack may not be aligned with the natural size of the immediately following ldind, stind, ldfld, stfld, ldobj, stobj, initblk, or cpblk instructions. Ldc.R4 pushes the supplied value of type float32 as type F (float) onto the evaluation stack.

Unbox converts the boxed representation of a value type to its unboxed form. Ldc.R8 pushes the supplied value of type float64 as type F (float) onto the evaluation stack.

Unbox.Any converts the boxed representation of the type specified in the instruction to unboxed form. Ldelem loads elements from the specified array index into the top of the evaluation stack according to the type specified in the instruction.

Volatile specifies that the address currently at the top of the calculation stack can be volatile, and the results of reading that location cannot be cached, or multiple storage areas for that address cannot be canceled. Ldelem.I loads elements of type native int at the specified array index into the top of the evaluation stack as native int.

Xor evaluates the bitwise XOR of the two values at the top of the evaluation stack and pushes the result onto the evaluation stack.

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.