instruction.int.inc

Переключить прокрутку окна
Загрузить этот исходный код

;
 ;  Исходный код среды исполнения ПВТ-ОО.
 ;
 ;  Этот исходный код является частью проекта ПВТ-ОО.
 ;
 ;  Copyright © 2021 Малик Разработчик
 ;
 ;  Это свободная программа: вы можете перераспространять её и/или
 ;  изменять её на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
 ;  в каком она была опубликована Фондом свободного программного обеспечения;
 ;  либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.
 ;
 ;  Эта программа распространяется в надежде, что она может быть полезна,
 ;  но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
 ;  или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЁННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
 ;  общественной лицензии GNU.
 ;
 ;  Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
 ;  вместе с этой программой. Если это не так, см.
 ;  <http://www.gnu.org/licenses/>.
;

; <fold push/pop/peek>
    if(used inst$ipush) ; <fold >
        inst ipush ; (value in eax)
                    push1
                    mov     eax, eax ; старшая часть регистра rax обнулится
                    mov     qword[rsp+$08], $00
                    mov     qword[rsp+$00], rax
                    set     TAG_INT
        end_inst
    end if ; </fold>

    if(used inst$ipop) ; <fold >
        inst ipop ; (): value in eax
                    overify TAG_INT
                    mov     eax, [rsp]
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$ipeek) ; <fold >
        inst ipeek ; (): value in eax
                    overify TAG_INT
                    mov     eax, [rsp]
        end_inst
    end if ; </fold>
; </fold>

; <fold conversion>
    if(used inst$itob) ; <fold >
                label   inst$itob at inst$btoi
    end if ; </fold>

    if(used inst$itos) ; <fold >
                label   inst$itos at inst$stoi
    end if ; </fold>

    if(used inst$itoi2) ; <fold >
        inst itoi2
                    overify TAG_INT
                    vmovd   xmm0, [rsp]
                    vmovdqa xword[rsp], xmm0
                    set     TAG_INT2
        end_inst
    end if ; </fold>

    if(used inst$itoi4) ; <fold >
        inst itoi4
                    overify TAG_INT
                    vmovd   xmm0, [rsp]
                    vmovdqa xword[rsp], xmm0
                    set     TAG_INT4
        end_inst
    end if ; </fold>

    if(used inst$itoi8) ; <fold >
        inst itoi8
                    overify TAG_INT
                    push1
                    vmovd   xmm0, [rsp+$10]
                    vmovdqu yword[rsp], ymm0
                    set     TAG_INT8
        end_inst
    end if ; </fold>

    if(used inst$itol) ; <fold >
        inst itol
                    overify TAG_INT
                    movsxd  rax, [rsp]
                    mov     qword[rsp], rax
                    set     TAG_LONG
        end_inst
    end if ; </fold>

    if(used inst$itof) ; <fold >
        inst itof
                    overify TAG_INT
                    vpxor   xmm0, xmm0, xmm0
                    vcvtsi2ss xmm0, xmm0, dword[rsp]
                    vmovdqa xword[rsp], xmm0
                    set     TAG_FLOAT
        end_inst
    end if ; </fold>

    if(used inst$itod) ; <fold >
        inst itod
                    overify TAG_INT
                    vpxor   xmm0, xmm0, xmm0
                    vcvtsi2sd xmm0, xmm0, dword[rsp]
                    vmovdqa xword[rsp], xmm0
                    set     TAG_DOUBLE
        end_inst
    end if ; </fold>

    if(used inst$itox) ; <fold >
        inst itox
                    overify TAG_INT
                    fild    dword[rsp]
                    mov     qword[rsp+$08], $00
                    fstp    tbyte[rsp+$00]
                    set     TAG_REAL
        end_inst
    end if ; </fold>

    if(used inst$itoc) ; <fold >
                label   inst$itoc at inst$svunpckl
    end if ; </fold>
; </fold>

; <fold relation>
    if(used inst$icmp) ; <fold >
        inst icmp
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$10]
                    cmp     eax, [rsp+$00]
                    jl      .L
                    je      .E
                    mov     eax, $01
                    jmp     @F
            .L:     mov     eax, -$01
                    jmp     @F
            .E:     xor     eax, eax
            @@:     mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>
; </fold>

; <fold bitwise>
    if(used inst$inot) ; <fold >
        inst inot
                    overify TAG_INT
                    not     dword[rsp]
        end_inst
    end if ; </fold>

    if(used inst$iand) ; <fold >
        inst iand
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$00]
                    and     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$ior) ; <fold >
        inst ior
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$00]
                    or      dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$ixor) ; <fold >
        inst ixor
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$00]
                    xor     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>
; </fold>

; <fold scalar>
    if(used inst$isneg | used inst$ivneg) ; <fold >
        inst isneg, ivneg
                    overify TAG_INT
                    neg     dword[rsp]
        end_inst
    end if ; </fold>

    if(used inst$ismul | used inst$ivmul) ; <fold >
        inst ismul, ivmul
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$10]
                    imul    eax, [rsp+$00]
                    mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$isdiv) ; <fold >
        inst isdiv
                    overify TAG_INT, TAG_INT
                    mov     ecx, [rsp+$00]
                    test    ecx, ecx
                    jnz     @F
                    throw   ArithmeticException
            @@:     mov     eax, [rsp+$10]
                    cmp     eax, -$80000000
                    jne     .L.000
                    cmp     ecx, -$00000001
                    je      .L.001
            .L.000: cdq
                    idiv    ecx
            .L.001: mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$isdivu) ; <fold >
        inst isdivu
                    overify TAG_INT, TAG_INT
                    mov     ecx, [rsp+$00]
                    test    ecx, ecx
                    jnz     @F
                    throw   ArithmeticException
            @@:     mov     eax, [rsp+$10]
                    xor     edx, edx
                    div     ecx
                    mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$isrem) ; <fold >
        inst isrem
                    overify TAG_INT, TAG_INT
                    mov     ecx, [rsp+$00]
                    test    ecx, ecx
                    jnz     @F
                    throw   ArithmeticException
            @@:     mov     eax, [rsp+$10]
                    cmp     eax, -$80000000
                    jne     .L.000
                    cmp     ecx, -$00000001
                    je      .L.001
            .L.000: cdq
                    idiv    ecx
                    jmp     .L.002
            .L.001: xor     edx, edx
            .L.002: mov     dword[rsp+$10], edx
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$isremu) ; <fold >
        inst isremu
                    overify TAG_INT, TAG_INT
                    mov     ecx, [rsp+$00]
                    test    ecx, ecx
                    jnz     @F
                    throw   ArithmeticException
            @@:     mov     eax, [rsp+$10]
                    xor     edx, edx
                    div     ecx
                    mov     dword[rsp+$10], edx
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$isadd | used inst$ivadd) ; <fold >
        inst isadd, ivadd
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$00]
                    add     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$issub | used inst$ivsub) ; <fold >
        inst issub, ivsub
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$00]
                    sub     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$issar | used inst$ivsar) ; <fold >
        inst issar, ivsar
                    overify TAG_INT, TAG_INT
                    mov     ecx, [rsp+$00]
                    sar     dword[rsp+$10], cl
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$issal | used inst$ivsal) ; <fold >
        inst issal, ivsal
                    overify TAG_INT, TAG_INT
                    mov     ecx, [rsp+$00]
                    sal     dword[rsp+$10], cl
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$isshr | used inst$ivshr) ; <fold >
        inst isshr, ivshr
                    overify TAG_INT, TAG_INT
                    mov     ecx, [rsp+$00]
                    shr     dword[rsp+$10], cl
                    pop1set
        end_inst
    end if ; </fold>
; </fold>

; <fold vector>
    if(used inst$ivpack) ; <fold >
        inst ivpack
                    overify TAG_INT
                    vmovd   xmm0, [rsp]
                    vpackusdw xmm0, xmm0, xmm0
                    vmovd   eax, xmm0
                    movsx   eax, ax
                    mov     dword[rsp], eax
        end_inst
    end if ; </fold>

    if(used inst$ivunpckl) ; <fold >
        inst ivunpckl
                    overify TAG_INT
                    mov     eax, [rsp]
                    mov     qword[rsp], rax
                    set     TAG_LONG
        end_inst
    end if ; </fold>

    if(used inst$ivunpcku) ; <fold >
        inst ivunpcku
                    overify TAG_INT
                    mov     eax, [rsp]
                    sal     rax, $20
                    mov     qword[rsp], rax
                    set     TAG_LONG
        end_inst
    end if ; </fold>

    if(used inst$ivg) ; <fold >
        inst ivg
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$10]
                    cmp     eax, [rsp+$00]
                    setng   al
                    dec     al
                    movsx   eax, al
                    mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$ivge) ; <fold >
        inst ivge
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$10]
                    cmp     eax, [rsp+$00]
                    setnge  al
                    dec     al
                    movsx   eax, al
                    mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$ivl) ; <fold >
        inst ivl
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$10]
                    cmp     eax, [rsp+$00]
                    setnl   al
                    dec     al
                    movsx   eax, al
                    mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$ivle) ; <fold >
        inst ivle
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$10]
                    cmp     eax, [rsp+$00]
                    setnle  al
                    dec     al
                    movsx   eax, al
                    mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$ive) ; <fold >
        inst ive
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$10]
                    cmp     eax, [rsp+$00]
                    setne   al
                    dec     al
                    movsx   eax, al
                    mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>

    if(used inst$ivne) ; <fold >
        inst ivne
                    overify TAG_INT, TAG_INT
                    mov     eax, [rsp+$10]
                    cmp     eax, [rsp+$00]
                    sete    al
                    dec     al
                    movsx   eax, al
                    mov     dword[rsp+$10], eax
                    pop1set
        end_inst
    end if ; </fold>
; </fold>