# The OS/K Team licenses this file to you under the MIT license. # See the LICENSE file in the project root for more information. #---------------------------------------------------------------------------# # Special instructions # #---------------------------------------------------------------------------# # # Initiate machine shutdown (STOP) # # THROW #SHT # # Throws: # #SYS if not in supervisor mode # #ILL if disabled through DV # #SHT otherwise # stop #---------------------------------------------------------------------------# # Logical instructions # #---------------------------------------------------------------------------# # # Bitwise NOT operation # # $1 = NOT($1) # # Preserves all flags # !not rm # # Bitwise OR operation # # $1 = $1 OR $2 # # Clears OF and CF # Sets ZF and SF according to the result # !or rm rim # # Bitwise AND operation # # $1 = $1 AND $2 # # Clears OF and CF # Sets ZF and SF according to the result # !and rm rim # # Bitwise XOR operation # # $1 = $1 XOR $2 # # Clears OF and CF # Sets ZF and SF according to the result # !xor rm rim # To document !shl rm rim !shr rm rim #---------------------------------------------------------------------------# # Arithmetic instructions # #---------------------------------------------------------------------------# # # Arithmetical SGN operation # # IF ($1 == 0) THEN # $2 = 0 # ELIF ($1 GT 0) THEN # $2 = 1 # ELSE # $2 = LONG_MIN # FI # # Treats $1 and $2 as signed values # Sets ZF and SF according to the result # !sgn rm rim # # Arithmetical NEG operation # # $1 = NOT($1) + 1 # # Sets CF if $1 == 0; clears it otherwise # Sets OF if $1 == $LONG_MIN; clears it otherwise # Sets ZF and SF according to the result # !neg rm # # Arithmetical INC operation # # $1 = $1 + 1 # # Preserves CF # Sets OF if $1 == $LONG_MAX, clears it otherwise # Sets ZF and SF according to the result # !inc rm # # Arithmetical DEC operation # # $1 = $1 - 1 # # Preserves CF # Sets OF if $1 == $LONG_MIN, clears it otherwise # Sets ZF and SF according to the result # !dec rm # # Arithmetical ADD operation # # $1 = $1 + $2 # # Sets CF if unsigned integer overflow occur, clears it otherwise # Sets OF is signed integer overflow occur, clears it otherwise # Sets ZF and SF according to the result # !add rm rim # # Arithmetical SUB operation # # $1 = $1 - $2 # # Sets CF if unsigned integer overflow occur, clears it otherwise # Sets OF is signed integer overflow occur, clears it otherwise # Sets ZF and SF according to the result # !sub rm rim # # Arithmetical unsigned MUL operation # # $1 = LO($1 * $2) # # Sets CF and OF if HI($1 * $2) > 0, clears them otherwise # Preserves ZF and SF # !mul rm rim # # Arithmetical unsigned DIV operation # # $1 = $1 DIV $2 # # Preserves all flags # !div rm rim # # Arithmetical unsigned MOD operation # # $1 = $1 MOD $2 # # Preserves all flags # !mod rm rim # # Arithmetical unsigned 128-bit MUL operation # # RDX = HI(RAX * $1) # RAX = LO(RAX * $1) # # Sets CF and OF if HI($1 * $2) > 0, clears them otherwise # Preserves ZF and SF # mul2 rim # # Arithmetical unsigned combined DIV and MOD operations # # RDX = (RAX MOD $1) # RAX = (RAX DIV $1) # # Preserves all flags # div2 rim #---------------------------------------------------------------------------# # Comparison instructions # #---------------------------------------------------------------------------# # # TEST Comparaison instruction # # $1 AND $2 # # Clears OF and CF # Sets ZF and SF according to the result # test rim rim # # CMP Comparaison instruction # # $1 - $2 # # Sets CF if unsigned integer overflow occur, clears it otherwise # Sets OF is signed integer overflow occur, clears it otherwise # Sets ZF and SF according to the result # cmp rim rim #---------------------------------------------------------------------------# # Jump instructions # #---------------------------------------------------------------------------# # # Unconditional jump (JMP) instruction # # RIP = CR1 + $1 # !j ri !jmp ri # # RCX-dependent jump (LOOP) instruction # # IF (RCX > 0) THEN # RCX = RCX - 1 # RIP = CR1 + $1 # FI # !loop ri #---------------------------------------------------------------------------# # Movement instructions # #---------------------------------------------------------------------------# # # Load Effective Address (LEA) instruction # # $1 = ADDR($2) # # For instance: # LEA RAX, [RBX + RCX + 4] # will result in: # RAX = RBX + RCX + 4 # # Preserves all flags # !lea rm m # # Movement (MOV) instruction # # $1 = $2 # !mov rm rim # # Exchange (XCHG) instruction # # $_ = $1 # $1 = $2 # $2 = $_ # !xchg rm rim # # Compare-and-exchange (CMPXCHG) instruction # # IF ($1 == RAX) THEN # $1 = $2 # ZF = 1 # ELSE # RAX = $1 # ZF = 0 # FI # # Preserves CF, OF and SF # cmpxchg rm rim # Undocumented # movb rm rim # movw rm rim # movl rm rim # movt rm rim #---------------------------------------------------------------------------# # Stack manipulation instructions # #---------------------------------------------------------------------------# # # PUSH value onto stack # # RSP = RSP - 8 # *RSP = $1 # # Throws: # #STA if RBP MOD 8 > 0 # #STA if RSP MOD 8 > 0 # #STU if RSP > RBP # !push rim # # POP value from stack # # $1 = *RSP # RSP = RSP + 8 # # Throws: # #STA if RBP MOD 8 > 0 # #STA if RSP MOD 8 > 0 # #STU if RSP >= RBP # !pop rm # # Unconditional jump with possible return (CALL) # # PUSH(RIP) # JMP(RIP) # # Throws: # See PUSH and JMP # !call rim # # Return to caller (RET) # # POP(RIP) # # Throws: # See POP # !ret # # Make new stack frame (ENTER) # # PUSH(RBP) # RBP = RSP # # Throws: # See PUSH # enter # # Leave stack frame (LEAVE) # # RBP = *RSP # RSP = RSP + 8 # !leave #---------------------------------------------------------------------------# # Supervisor only instructions # #---------------------------------------------------------------------------# pushf popf # # Clear or set interrupt flag (CLI/STI) # # Throws: # #SYS if not in supervisor mode # cli sti # # Call an architecture-reserved function slot of device (DEVCTL) # # See dv/DEVAPI # devctl rim rim # # Call a device-defined function slot of device (IOCALL) # # See dv/DEVAPI # iocall rim rim #---------------------------------------------------------------------------# # Misc. instructions # #---------------------------------------------------------------------------# # # Do nothing (NOOP) # # (nothing) # # Throws: # (nothing) # # Preserves all flags # nop # # Get code/date offset (GCO/GCD) # # $1 = CR1 (GCO) # $1 = CR2 (GCD) # gco rm gcd rm # # Clear base volatile registers (CLR) # # RAX = RBX = RCX = RDX = 0 # RSX = RBI = RDI = RSI = 0 # clr # # Clear argument registers (CLA) # # AX0 = AX1 = AX2 = AX3 = 0 # AX4 = AX5 = AX6 = AX7 = 0 # cla # # Clear base non-volatile registers (CLN) # # NX0 = NX1 = NX2 = NX3 = 0 # NX4 = NX5 = NX6 = NX7 = 0 # cln # # Send a character to standard output # # Throws: # #PRN if DV text mode enabled # #PRN if graphic mode enabled # prn rim #---------------------------------------------------------------------------# # Debugging instructions # #---------------------------------------------------------------------------# # # Breakpoint instruction (BREAK) # # (cause register dump on standard error) # (wait for user input before proceeeding) # !break # # Step-by-step execution (STEP) # # IF $1 == 0 THEN # (disable step-by-step execution) # ELSE # (enable step-by-step execution) # FI # step rim #---------------------------------------------------------------------------#