kvisc/vm/in/INSTRS

# The OS/K Team licenses this file to you under the MIT license.
# See the LICENSE file in the project root for more information.

stop
nop

#---------------------------------------------------------------------------#
# 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


!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                                                        #
#---------------------------------------------------------------------------#

#
# 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

#---------------------------------------------------------------------------#