NEG Negate (Two's Complement; i.e., Multiply by −1)

Flags affected:

        O D I T S Z A P C  OF: Overflow flag  TF: Trap flag AF: Aux carry
        F F F F F F F F F  DF: Direction flag SF: Sign flag PF: Parity flag
        *       * * * * *  IF: Interrupt flag ZF: Zero flag CF: Carry flag

Legal forms:

        NEG r8
        NEG m8
        NEG r16
        NEG m16
        NEG r32        386+
        NEG m32        386+

Examples:

        NEG AL
        NEG DX
        NEG ECX
        NEG BYTE [BX]   ; Negates BYTE quantity at [BX]
        NEG WORD [DI]   ; Negates WORD quantity at [BX]
        NEG DWORD [EAX] ; Negates DWORD quantity at [EAX]

Notes:

This is the assembly language equivalent of multiplying a value by −1. Keep in mind that negation is not the same as simply inverting each bit in the operand. (Another instruction, NOT, does that.) The process is also known as generating the two's complement of a value. The two's complement of a value added to that value yields zero. −1 = $FF; −2 = $FE; −3 = $FD; and so forth.

If the operand is 0, CF is cleared and ZF is set; otherwise, CF is set and ZF is cleared. If the operand contains the maximum negative value (−128 for 8-bit or −32,768 for 16-bit), the operand does not change, but OF and CF are set. SF is set if the result is negative, or else SF is cleared. PF is set if the low-order 8 bits of the result contain an even number of set (1) bits; otherwise, PF is cleared.

Note

You must use a size specifier (BYTE, WORD, DWORD) with memory data!

        r8 = AL AH BL BH CL CH DL DH        r16 = AX BX CX DX BP SP SI DI
        sr = CS DS SS ES FS GS              r32 = EAX EBX ECX EDX EBP ESP ESI EDI
        m8 = 8-bit memory data              m16 = 16-bit memory data
        m32 = 32-bit memory data            i8 = 8-bit immediate data
        i16 = 16-bit immediate data         i32 = 32-bit immediate data
        d8 = 8-bit signed displacement      d16 = 16-bit signed displacement
        d32 = 32-bit unsigned displacement