scalar.divu.inc

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

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

; <fold скалярное беззнаковое деление>
    if(used inst$sdivud2) ; <fold returns double2>
                    label       inst$sdivud2 at inst$sdivd2
    end if ; </fold>

    if(used inst$sdivud4) ; <fold returns double4>
                    proc        inst$sdivud4
                    vmulpd      ymm1, ymm1, [cons$smuld4.q0]
                    vmulpd      ymm2, ymm1, ymm1
                    vextractf128 xmm3, ymm2, $01
                    vhaddpd     xmm2, xmm2, xmm3
                    vhaddpd     xmm2, xmm2, xmm2
                    vinsertf128 ymm2, ymm2, xmm2, $01
                    vdivpd      ymm1, ymm1, ymm2
                    vshuff64x2  ymm4, ymm0, ymm0, $02
                    vshuff64x2  ymm6, ymm4, ymm4, $01
                    vshufpd     ymm5, ymm4, ymm4, $05
                    vshufpd     ymm7, ymm6, ymm6, $05
                    vmulpd      ymm4, ymm4, [cons$smuld4.q0]
                    vmulpd      ymm5, ymm5, [cons$smuld4.q1]
                    vmulpd      ymm6, ymm6, [cons$smuld4.q2]
                    vmulpd      ymm7, ymm7, [cons$smuld4.q3]
                    vmulpd      ymm3, ymm1, ymm7
                    vmulpd      ymm2, ymm1, ymm6
                    vmulpd      ymm0, ymm1, ymm5
                    vmulpd      ymm1, ymm1, ymm4
                    vextractf128 xmm4, ymm1, $01
                    vextractf128 xmm5, ymm0, $01
                    vextractf128 xmm6, ymm2, $01
                    vextractf128 xmm7, ymm3, $01
                    vinsertf128 ymm1, ymm1, xmm2, $01
                    vinsertf128 ymm2, ymm0, xmm3, $01
                    vinsertf128 ymm0, ymm4, xmm6, $01
                    vinsertf128 ymm3, ymm5, xmm7, $01
                    vaddpd      ymm0, ymm1, ymm0
                    vaddpd      ymm1, ymm2, ymm3
                    vshufpd     ymm2, ymm0, ymm1, $00
                    vshufpd     ymm3, ymm0, ymm1, $0f
                    vaddpd      ymm0, ymm2, ymm3
                    ret
                    end_proc
    end if ; </fold>

    if(used inst$sdivud8) ; <fold returns double8>
                    proc        inst$sdivud8
                    vmulpd      zmm01, zmm01, [cons$smuld8.o0]
                    vmulpd      zmm02, zmm01, zmm01, {rn-sae}
                    vextractf64x2 xmm03, zmm02, $01
                    vextractf64x2 xmm04, zmm02, $02
                    vextractf64x2 xmm05, zmm02, $03
                    vhaddpd     xmm02, xmm02, xmm03
                    vhaddpd     xmm03, xmm04, xmm05
                    vhaddpd     xmm02, xmm02, xmm03
                    vhaddpd     xmm02, xmm02, xmm02
                    vbroadcastsd zmm02, xmm02
                    vdivpd      zmm01, zmm01, zmm02
                    vshuff64x2  zmm08, zmm00, zmm00, $e4
                    vshuff64x2  zmm10, zmm08, zmm08, $b1
                    vshuff64x2  zmm12, zmm08, zmm08, $4e
                    vshuff64x2  zmm14, zmm08, zmm08, $1b
                    vshufpd     zmm09, zmm08, zmm08, $55
                    vshufpd     zmm11, zmm10, zmm10, $55
                    vshufpd     zmm13, zmm12, zmm12, $55
                    vshufpd     zmm15, zmm14, zmm14, $55
                    vmulpd      zmm08, zmm08, [cons$smuld8.o0]
                    vmulpd      zmm09, zmm09, [cons$smuld8.o1]
                    vmulpd      zmm10, zmm10, [cons$smuld8.o2]
                    vmulpd      zmm11, zmm11, [cons$smuld8.o3]
                    vmulpd      zmm12, zmm12, [cons$smuld8.o4]
                    vmulpd      zmm13, zmm13, [cons$smuld8.o5]
                    vmulpd      zmm14, zmm14, [cons$smuld8.o6]
                    vmulpd      zmm15, zmm15, [cons$smuld8.o7]
                    vmulpd      zmm07, zmm01, zmm15, {rn-sae}
                    vmulpd      zmm06, zmm01, zmm14, {rn-sae}
                    vmulpd      zmm05, zmm01, zmm13, {rn-sae}
                    vmulpd      zmm04, zmm01, zmm12, {rn-sae}
                    vmulpd      zmm03, zmm01, zmm11, {rn-sae}
                    vmulpd      zmm02, zmm01, zmm10, {rn-sae}
                    vmulpd      zmm00, zmm01, zmm09, {rn-sae}
                    vmulpd      zmm01, zmm01, zmm08, {rn-sae}
                    vextractf64x4 ymm08, zmm01, $01
                    vextractf64x4 ymm09, zmm00, $01
                    vextractf64x4 ymm10, zmm02, $01
                    vextractf64x4 ymm11, zmm03, $01
                    vextractf64x4 ymm12, zmm04, $01
                    vextractf64x4 ymm13, zmm05, $01
                    vextractf64x4 ymm14, zmm06, $01
                    vextractf64x4 ymm15, zmm07, $01
                    vinsertf64x4 zmm01, zmm01, ymm02, $01
                    vinsertf64x4 zmm02, zmm04, ymm06, $01
                    vinsertf64x4 zmm04, zmm00, ymm03, $01
                    vinsertf64x4 zmm06, zmm05, ymm07, $01
                    vinsertf64x4 zmm00, zmm08, ymm10, $01
                    vinsertf64x4 zmm03, zmm12, ymm14, $01
                    vinsertf64x4 zmm05, zmm09, ymm11, $01
                    vinsertf64x4 zmm07, zmm13, ymm15, $01
                    vaddpd      zmm01, zmm01, zmm00
                    vaddpd      zmm00, zmm02, zmm03
                    vaddpd      zmm02, zmm04, zmm05
                    vaddpd      zmm03, zmm06, zmm07
                    vshuff64x2  zmm04, zmm01, zmm00, $88
                    vshuff64x2  zmm05, zmm01, zmm00, $dd
                    vshuff64x2  zmm06, zmm02, zmm03, $88
                    vshuff64x2  zmm07, zmm02, zmm03, $dd
                    vaddpd      zmm00, zmm04, zmm05
                    vaddpd      zmm01, zmm06, zmm07
                    vshufpd     zmm02, zmm00, zmm01, $00
                    vshufpd     zmm03, zmm00, zmm01, $ff
                    vaddpd      zmm00, zmm02, zmm03
                    ret
                    end_proc
    end if ; </fold>

    if(used inst$sdivuf2) ; <fold returns float2>
                    label       inst$sdivuf2 at inst$sdivf2
    end if ; </fold>

    if(used inst$sdivuf4) ; <fold returns float4>
                    proc        inst$sdivuf4
                    vmulps      xmm1, xmm1, [cons$smulf4.q0]
                    vmulps      xmm2, xmm1, xmm1
                    vhaddps     xmm2, xmm2, xmm2
                    vhaddps     xmm2, xmm2, xmm2
                    vdivps      xmm1, xmm1, xmm2
                    vshufps     xmm4, xmm0, xmm0, $e4
                    vshufps     xmm5, xmm4, xmm4, $b1
                    vshufps     xmm6, xmm4, xmm4, $4e
                    vshufps     xmm7, xmm4, xmm4, $1b
                    vmulps      xmm4, xmm4, [cons$smulf4.q0]
                    vmulps      xmm5, xmm5, [cons$smulf4.q1]
                    vmulps      xmm6, xmm6, [cons$smulf4.q2]
                    vmulps      xmm7, xmm7, [cons$smulf4.q3]
                    vmulps      xmm3, xmm1, xmm7
                    vmulps      xmm2, xmm1, xmm6
                    vmulps      xmm0, xmm1, xmm5
                    vmulps      xmm1, xmm1, xmm4
                    vhaddps     xmm1, xmm1, xmm0
                    vhaddps     xmm0, xmm2, xmm3
                    vhaddps     xmm0, xmm1, xmm0
                    ret
                    end_proc
    end if ; </fold>

    if(used inst$sdivuf8) ; <fold returns float8>
                    proc        inst$sdivuf8
                    vmulps      ymm01, ymm01, [cons$smulf8.o0]
                    vmulps      ymm02, ymm01, ymm01
                    vextractf128 xmm03, ymm02, $01
                    vhaddps     xmm02, xmm02, xmm03
                    vhaddps     xmm02, xmm02, xmm02
                    vhaddps     xmm02, xmm02, xmm02
                    vinsertf128 ymm02, ymm02, xmm02, $01
                    vdivps      ymm01, ymm01, ymm02
                    vmovdqa     ymm08, ymm00
                    vextractf128 xmm12, ymm08, $01
                    vinsertf128 ymm12, ymm12, xmm08, $01
                    vshufps     ymm09, ymm08, ymm08, $b1
                    vshufps     ymm10, ymm08, ymm08, $4e
                    vshufps     ymm11, ymm08, ymm08, $1b
                    vshufps     ymm13, ymm12, ymm12, $b1
                    vshufps     ymm14, ymm12, ymm12, $4e
                    vshufps     ymm15, ymm12, ymm12, $1b
                    vmulps      ymm08, ymm08, [cons$smulf8.o0]
                    vmulps      ymm09, ymm09, [cons$smulf8.o1]
                    vmulps      ymm10, ymm10, [cons$smulf8.o2]
                    vmulps      ymm11, ymm11, [cons$smulf8.o3]
                    vmulps      ymm12, ymm12, [cons$smulf8.o4]
                    vmulps      ymm13, ymm13, [cons$smulf8.o5]
                    vmulps      ymm14, ymm14, [cons$smulf8.o6]
                    vmulps      ymm15, ymm15, [cons$smulf8.o7]
                    vmulps      ymm07, ymm01, ymm15
                    vmulps      ymm06, ymm01, ymm14
                    vmulps      ymm05, ymm01, ymm13
                    vmulps      ymm04, ymm01, ymm12
                    vmulps      ymm03, ymm01, ymm11
                    vmulps      ymm02, ymm01, ymm10
                    vmulps      ymm00, ymm01, ymm09
                    vmulps      ymm01, ymm01, ymm08
                    vhaddps     ymm01, ymm01, ymm00
                    vhaddps     ymm00, ymm02, ymm03
                    vhaddps     ymm02, ymm04, ymm05
                    vhaddps     ymm03, ymm06, ymm07
                    vhaddps     ymm01, ymm01, ymm00
                    vhaddps     ymm00, ymm02, ymm03
                    vextractf128 xmm02, ymm01, $01
                    vextractf128 xmm03, ymm00, $01
                    vaddps      xmm01, xmm01, xmm02
                    vaddps      xmm00, xmm00, xmm03
                    vinsertf128 ymm00, ymm01, xmm00, $01
                    ret
                    end_proc
    end if ; </fold>

    if(used inst$sdivui) ; <fold returns int>
                    fast        inst$sdivui
                    fenter
                    test        dsc1, dsc1
                    jnz         .L.0000
                    fthrow      ArithmeticException
        .L.0000:    xor         dsc2, dsc2
                    div         dsc1
                    fleave
    end if ; </fold>

    if(used inst$sdivul) ; <fold returns long>
                    fast        inst$sdivul
                    fenter
                    test        qsc1, qsc1
                    jnz         .L.0000
                    fthrow      ArithmeticException
        .L.0000:    xor         qsc2, qsc2
                    div         qsc1
                    fleave
    end if ; </fold>
; </fold>