Int128.inc

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

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

; <fold avt.lang.math.Int128 — родной код>
    if(used avt.lang.math.Int128$signum$long2$) ; <fold returns int>
                    fast        avt.lang.math.Int128$signum$long2$, \
                                value, long2
                    fenter
                    cmp         qword [.value+$08], $00
                    jl          .L.0000
                    jg          .L.0002
                    cmp         qword [.value+$00], $00
                    je          .L.0001
                    jmp         .L.0002
        .L.0000:    mov         r00d, $ffffffff
                    freturn
        .L.0001:    mov         r00d, $00000000
                    freturn
        .L.0002:    mov         r00d, $00000001
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$compare$long2$long2$) ; <fold returns int>
                    fast        avt.lang.math.Int128$compare$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r00q, [.value0+$08]
                    cmp         r00q, [.value1+$08]
                    jl          .L.0000
                    jg          .L.0002
                    mov         r00q, [.value0+$00]
                    cmp         r00q, [.value1+$00]
                    je          .L.0001
                    ja          .L.0002
        .L.0000:    mov         r00d, $ffffffff
                    freturn
        .L.0001:    mov         r00d, $00000000
                    freturn
        .L.0002:    mov         r00d, $00000001
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$compareUnsigned$long2$long2$) ; <fold returns int>
                    fast        avt.lang.math.Int128$compareUnsigned$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r00q, [.value0+$08]
                    cmp         r00q, [.value1+$08]
                    jb          .L.0000
                    ja          .L.0002
                    mov         r00q, [.value0+$00]
                    cmp         r00q, [.value1+$00]
                    je          .L.0001
                    ja          .L.0002
        .L.0000:    mov         r00d, $ffffffff
                    freturn
        .L.0001:    mov         r00d, $00000000
                    freturn
        .L.0002:    mov         r00d, $00000001
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$neg$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$neg$long2$, \
                                value, long2
                    fenter
                    mov         r00q, [.value+$00]
                    mov         r02q, [.value+$08]
                    neg         r00q
                    adc         r02q, $00
                    neg         r02q
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$mul$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$mul$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r08q, [.value0+$00]
                    mov         r09q, [.value1+$00]
                    mov         r00q, r08q
                    mul         r09q
                    imul        r08q, [.value1+$08]
                    imul        r09q, [.value0+$08]
                    lea         r02q, [r02+r08*1+$00]
                    lea         r02q, [r02+r09*1+$00]
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$div$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$div$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r10q, [.value1+$00]
                    mov         r11q, [.value1+$08]
                    mov         r01q, r10q
                    or          r01q, r11q
                    jnz         @F
                    fthrow      ArithmeticException
             @@:    mov         r01q, r11q
                    sar         r01q, $ff
                    jz          @F
                    neg         r10q
                    adc         r11q, $00
                    neg         r11q
             @@:    mov         r00q, [.value0+$00]
                    mov         r02q, [.value0+$08]
                    mov         r12q, r02q
                    sar         r12q, $ff
                    jz          @F
                    neg         r00q
                    adc         r02q, $00
                    neg         r02q
             @@:    xor         r12q, r01q
                    xor         r08q, r08q
                    xor         r09q, r09q
                    mov         r01d, $00000080
                    ; r02:r00 — делимое => частное
                    ; r09:r08 — 0 => остаток
                    ; r11:r10 — делитель
             @@:    shl         r00q, $01
                    rcl         r02q, $01
                    rcl         r08q, $01
                    rcl         r09q, $01
                    cmp         r09q, r11q
                    ja          .L.0000
                    jb          .L.0001
                    cmp         r08q, r10q
                    jb          .L.0001
        .L.0000:    sub         r08q, r10q
                    sbb         r09q, r11q
                    inc         r00q
        .L.0001:    loop        @B
                    test        r12q, r12q
                    jz          @F
                    neg         r00q
                    adc         r02q, $00
                    neg         r02q
             @@:    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$divUnsigned$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$divUnsigned$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r10q, [.value1+$00]
                    mov         r11q, [.value1+$08]
                    mov         r01q, r10q
                    or          r01q, r11q
                    jnz         @F
                    fthrow      ArithmeticException
             @@:    xor         r08q, r08q
                    xor         r09q, r09q
                    mov         r00q, [.value0+$00]
                    mov         r02q, [.value0+$08]
                    mov         r01d, $00000080
                    ; r02:r00 — делимое => частное
                    ; r09:r08 — 0 => остаток
                    ; r11:r10 — делитель
             @@:    shl         r00q, $01
                    rcl         r02q, $01
                    rcl         r08q, $01
                    rcl         r09q, $01
                    cmp         r09q, r11q
                    ja          .L.0000
                    jb          .L.0001
                    cmp         r08q, r10q
                    jb          .L.0001
        .L.0000:    sub         r08q, r10q
                    sbb         r09q, r11q
                    inc         r00q
        .L.0001:    loop        @B
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$rem$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$rem$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r10q, [.value1+$00]
                    mov         r11q, [.value1+$08]
                    mov         r01q, r10q
                    or          r01q, r11q
                    jnz         @F
                    fthrow      ArithmeticException
             @@:    mov         r01q, r11q
                    sar         r01q, $ff
                    jz          @F
                    neg         r10q
                    adc         r11q, $00
                    neg         r11q
             @@:    mov         r08q, [.value0+$00]
                    mov         r09q, [.value0+$08]
                    mov         r12q, r09q
                    sar         r12q, $ff
                    jz          @F
                    neg         r08q
                    adc         r09q, $00
                    neg         r09q
             @@:    xor         r00q, r00q
                    xor         r02q, r02q
                    mov         r01d, $00000080
                    ; r09:r08 — делимое => частное
                    ; r02:r00 — 0 => остаток
                    ; r11:r10 — делитель
             @@:    shl         r08q, $01
                    rcl         r09q, $01
                    rcl         r00q, $01
                    rcl         r02q, $01
                    cmp         r02q, r11q
                    ja          .L.0000
                    jb          .L.0001
                    cmp         r00q, r10q
                    jb          .L.0001
        .L.0000:    sub         r00q, r10q
                    sbb         r02q, r11q
                    inc         r08q
        .L.0001:    loop        @B
                    test        r12q, r12q
                    jz          @F
                    neg         r00q
                    adc         r02q, $00
                    neg         r02q
             @@:    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$remUnsigned$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$remUnsigned$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r10q, [.value1+$00]
                    mov         r11q, [.value1+$08]
                    mov         r01q, r10q
                    or          r01q, r11q
                    jnz         @F
                    fthrow      ArithmeticException
             @@:    xor         r00q, r00q
                    xor         r02q, r02q
                    mov         r08q, [.value0+$00]
                    mov         r09q, [.value0+$08]
                    mov         r01d, $00000080
                    ; r09:r08 — делимое => частное
                    ; r02:r00 — 0 => остаток
                    ; r11:r10 — делитель
             @@:    shl         r08q, $01
                    rcl         r09q, $01
                    rcl         r00q, $01
                    rcl         r02q, $01
                    cmp         r02q, r11q
                    ja          .L.0000
                    jb          .L.0001
                    cmp         r00q, r10q
                    jb          .L.0001
        .L.0000:    sub         r00q, r10q
                    sbb         r02q, r11q
                    inc         r08q
        .L.0001:    loop        @B
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$add$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$add$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r00q, [.value0+$00]
                    mov         r02q, [.value0+$08]
                    add         r00q, [.value1+$00]
                    adc         r02q, [.value1+$08]
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$sub$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$sub$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r00q, [.value0+$00]
                    mov         r02q, [.value0+$08]
                    sub         r00q, [.value1+$00]
                    sbb         r02q, [.value1+$08]
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$max$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$max$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r00q, [.value1+$00]
                    mov         r02q, [.value1+$08]
                    mov         r08q, [.value0+$00]
                    mov         r09q, [.value0+$08]
                    cmp         r09q, r02q
                    jg          .L.0000
                    jl          .L.0001
                    cmp         r08q, r00q
                    jbe         .L.0001
        .L.0000:    vmovq       xmm0, r08q
                    vmovq       xmm1, r09q
                    jmp         .L.EXIT
        .L.0001:    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
        .L.EXIT:    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$maxUnsigned$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$maxUnsigned$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r00q, [.value1+$00]
                    mov         r02q, [.value1+$08]
                    mov         r08q, [.value0+$00]
                    mov         r09q, [.value0+$08]
                    cmp         r09q, r02q
                    ja          .L.0000
                    jb          .L.0001
                    cmp         r08q, r00q
                    jbe         .L.0001
        .L.0000:    vmovq       xmm0, r08q
                    vmovq       xmm1, r09q
                    jmp         .L.EXIT
        .L.0001:    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
        .L.EXIT:    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$min$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$min$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r00q, [.value1+$00]
                    mov         r02q, [.value1+$08]
                    mov         r08q, [.value0+$00]
                    mov         r09q, [.value0+$08]
                    cmp         r09q, r02q
                    jl          .L.0000
                    jg          .L.0001
                    cmp         r08q, r00q
                    jae         .L.0001
        .L.0000:    vmovq       xmm0, r08q
                    vmovq       xmm1, r09q
                    jmp         .L.EXIT
        .L.0001:    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
        .L.EXIT:    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$minUnsigned$long2$long2$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$minUnsigned$long2$long2$, \
                                value0, long2, \
                                value1, long2
                    fenter
                    mov         r00q, [.value1+$00]
                    mov         r02q, [.value1+$08]
                    mov         r08q, [.value0+$00]
                    mov         r09q, [.value0+$08]
                    cmp         r09q, r02q
                    jb          .L.0000
                    ja          .L.0001
                    cmp         r08q, r00q
                    jae         .L.0001
        .L.0000:    vmovq       xmm0, r08q
                    vmovq       xmm1, r09q
                    jmp         .L.EXIT
        .L.0001:    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
        .L.EXIT:    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$shiftLeft$long2$int$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$shiftLeft$long2$int$, \
                                value, long2, \
                                bits, int
                    fenter
                    mov         r00q, [.value+$00]
                    mov         r02q, [.value+$08]
                    mov         r01d, [.bits+$00]
                    test        r01d, $40
                    jz          @F
                    mov         r02q, r00q
                    xor         r00q, r00q
             @@:    shld        r02q, r00q, r01b
                    shl         r00q, r01b
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$shiftRight$long2$int$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$shiftRight$long2$int$, \
                                value, long2, \
                                bits, int
                    fenter
                    mov         r00q, [.value+$00]
                    mov         r02q, [.value+$08]
                    mov         r01d, [.bits+$00]
                    test        r01d, $40
                    jz          @F
                    mov         r00q, r02q
                    sar         r02q, $ff
             @@:    shrd        r00q, r02q, r01b
                    sar         r02q, r01b
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$shiftRightUnsigned$long2$int$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$shiftRightUnsigned$long2$int$, \
                                value, long2, \
                                bits, int
                    fenter
                    mov         r00q, [.value+$00]
                    mov         r02q, [.value+$08]
                    mov         r01d, [.bits+$00]
                    test        r01d, $40
                    jz          @F
                    mov         r00q, r02q
                    xor         r02q, r02q
             @@:    shrd        r00q, r02q, r01b
                    shr         r02q, r01b
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$rotateLeft$long2$int$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$rotateLeft$long2$int$, \
                                value, long2, \
                                bits, int
                    fenter
                    mov         r00q, [.value+$00]
                    mov         r02q, [.value+$08]
                    mov         r01d, [.bits+$00]
                    test        r01d, $40
                    jz          @F
                    xchg        r00q, r02q
             @@:    xor         r08q, r08q
                    shld        r08q, r02q, r01b
                    shld        r02q, r00q, r01b
                    shl         r00q, r01b
                    or          r00q, r08q
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$rotateRight$long2$int$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$rotateRight$long2$int$, \
                                value, long2, \
                                bits, int
                    fenter
                    mov         r00q, [.value+$00]
                    mov         r02q, [.value+$08]
                    mov         r01d, [.bits+$00]
                    test        r01d, $40
                    jz          @F
                    xchg        r00q, r02q
             @@:    xor         r08q, r08q
                    shrd        r08q, r00q, r01b
                    shrd        r00q, r02q, r01b
                    shr         r02q, r01b
                    or          r02q, r08q
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$fromLong$long$) ; <fold returns long2>
                    fast        avt.lang.math.Int128$fromLong$long$, \
                                value, long
                    fenter
                    mov         r00q, [.value+$00]
                    cqo
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r02q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$toFloat$long2$) ; <fold returns float>
                    fast        avt.lang.math.Int128$toFloat$long2$, \
                                value, long2
                    fenter
                    mov         r00q, [.value+$00]
                    mov         r02q, [.value+$08]
                    mov         r01q, r00q
                    or          r01q, r02q
                    jz          .L.EXIT
                    mov         r08q, r02q
                    shr         r08q, $20
                    and         r08q, avt.lang.math.Int128$FLOAT_SIGN_MASK
                    jz          @F
                    neg         r00q
                    adc         r02q, $00
                    neg         r02q
             @@:    mov         r01d, $000000fe
                    jmp         .L.0000
             @@:    shld        r02q, r00q, $01
                    shl         r00q, $01
                    dec         r01q
        .L.0000:    test        r02q, r02q
                    jns         @B
                    mov         r00q, [avt.lang.math.Int128$FLOAT_ROUND_MASK]
                    test        r02q, r00q
                    jz          @F
                    add         r02q, r00q
                    jnc         @F
                    rcr         r02q, $01
                    inc         r01q
             @@:    shl         r01q, $17
                    shr         r02q, $28
                    and         r02q, avt.lang.math.Int128$FLOAT_SIGNIFICAND_MASK
                    or          r01q, r02q
                    or          r01q, r08q
        .L.EXIT:    vmovq       xmm0, r01q
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$toDouble$long2$) ; <fold returns double>
                    fast        avt.lang.math.Int128$toDouble$long2$, \
                                value, long2
                    fenter
                    mov         r00q, [.value+$00]
                    mov         r02q, [.value+$08]
                    mov         r01q, r00q
                    or          r01q, r02q
                    jz          .L.EXIT
                    mov         r08q, r02q
                    and         r08q, [avt.lang.math.Int128$DOUBLE_SIGN_MASK]
                    jz          @F
                    neg         r00q
                    adc         r02q, $00
                    neg         r02q
             @@:    mov         r01d, $0000047e
                    jmp         .L.0000
             @@:    shld        r02q, r00q, $01
                    shl         r00q, $01
                    dec         r01q
        .L.0000:    test        r02q, r02q
                    jns         @B
                    mov         r00q, [avt.lang.math.Int128$DOUBLE_ROUND_MASK]
                    test        r02q, r00q
                    jz          @F
                    add         r02q, r00q
                    jnc         @F
                    rcr         r02q, $01
                    inc         r01q
             @@:    shl         r01q, $34
                    shr         r02q, $0b
                    and         r02q, [avt.lang.math.Int128$DOUBLE_SIGNIFICAND_MASK]
                    or          r01q, r02q
                    or          r01q, r08q
        .L.EXIT:    vmovq       xmm0, r01q
                    fleave
    end if ; </fold>

    if(used avt.lang.math.Int128$toReal$long2$) ; <fold returns real>
                    fast        avt.lang.math.Int128$toReal$long2$, \
                                value, long2
                    fenter
                    mov         r00q, [.value+$00]
                    mov         r02q, [.value+$08]
                    mov         r01q, r00q
                    or          r01q, r02q
                    jz          .L.EXIT
                    mov         r08q, r02q
                    shr         r08q, $30
                    and         r08q, -avt.lang.math.Int128$REAL_SIGN_MASK
                    jz          @F
                    neg         r00q
                    adc         r02q, $00
                    neg         r02q
             @@:    mov         r01d, $0000407e
                    jmp         .L.0000
             @@:    shld        r02q, r00q, $01
                    shl         r00q, $01
                    dec         r01q
        .L.0000:    test        r02q, r02q
                    jns         @B
                    test        r00q, r00q
                    jns         @F
                    add         r02q, $01
                    jnc         @F
                    rcr         r02q, $01
                    inc         r01q
             @@:    or          r01q, r08q
                    mov         qword [.value+$00], r02q
                    mov         qword [.value+$08], r01q
        .L.EXIT:    fld         tbyte [.value+$00]
                    fleave
    end if ; </fold>
; </fold>