vector.new.inc

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

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

; <fold векторное конструирование>
    ; <fold первые (N–1) операндов — на стаке, последний операнд — на аккумуляторе, результат — на аккумуляторе>
        macro newvd2 {
                        vmovq       xmm1, [rsp+$00]
                        vpslldq     xmm0, xmm0, $08
                        vpor        xmm0, xmm0, xmm1
                        __pop       $01
        }

        macro newvd4 {
                        vmovq       qword [rsp+$08], xmm0
                        vpcmpeqq    ymm2, ymm0, ymm0
                        vmovdqa     xmm1, [cons$int4.newvd]
                        vpgatherdq  ymm0, [rsp+x01*8+$00], ymm2
                        __pop       $03
        }

        macro newvd8 {
                        vmovq       qword [rsp+$08], xmm0
                        vpcmpeqq    msk1, zmm0, zmm0
                        vmovdqa     ymm1, [cons$int8.newvd]
                        vpgatherdq  zmm0\{k1\}, [rsp+y01*8+$00]
                        __pop       $07
        }

        macro newvf2 {
                        vmovd       xmm1, [rsp+$00]
                        vpslldq     xmm0, xmm0, $04
                        vpor        xmm0, xmm0, xmm1
                        __pop       $01
        }

        macro newvf4 {
                        vmovd       dword [rsp+$04], xmm0
                        vpcmpeqd    xmm2, xmm0, xmm0
                        vmovdqa     xmm1, [cons$int4.newvf]
                        vpgatherdd  xmm0, [rsp+x01*4+$00], xmm2
                        __pop       $03
        }

        macro newvf8 {
                        vmovd       dword [rsp+$04], xmm0
                        vpcmpeqd    ymm2, ymm0, ymm0
                        vmovdqa     ymm1, [cons$int8.newvf]
                        vpgatherdd  ymm0, [rsp+y01*4+$00], ymm2
                        __pop       $07
        }

        macro newvb2 {
                        shl         dsc0, $08
                        mov         bsc0, [rsp+$00]
                        movzx       dsc0, wsc0
                        vmovd       xmm0, dsc0
                        __pop       $01
        }

        macro newvb4 {
            repeat(3)
                            shl         dsc0, $08
                            mov         bsc0, [rsp+(%-1)*$10]
            end repeat
                        vmovd       xmm0, dsc0
                        __pop       $03
        }

        macro newvb8 {
            repeat(7)
                            shl         qsc0, $08
                            mov         bsc0, [rsp+(%-1)*$10]
            end repeat
                        vmovq       xmm0, qsc0
                        __pop       $07
        }

        macro newvs2 {
                        shl         dsc0, $10
                        mov         wsc0, [rsp+$00]
                        vmovd       xmm0, dsc0
                        __pop       $01
        }

        macro newvs4 {
            repeat(3)
                            shl         qsc0, $10
                            mov         wsc0, [rsp+(%-1)*$10]
            end repeat
                        vmovq       xmm0, qsc0
                        __pop       $03
        }

        macro newvs8 {
                        mov         wsc1, [rsp+$30]
            repeat(6)
                if(% > 3)
                                shl         qsc0, $10
                                mov         wsc0, [rsp+(%-4)*$10]
                else
                                shl         qsc1, $10
                                mov         wsc1, [rsp+(%+3)*$10]
                end if
            end repeat
                        vmovq       xmm0, qsc0
                        vmovq       xmm1, qsc1
                        vpslldq     xmm0, xmm0, $08
                        vpor        xmm0, xmm0, xmm1
                        __pop       $07
        }

        macro newvi2 {
                        mov         dsc1, [rsp+$00]
                        shl         qsc0, $20
                        or          qsc0, qsc1
                        vmovq       xmm0, qsc0
                        __pop       $01
        }

        macro newvi4 {
                        mov         dword [rsp+$04], dsc0
                        vpcmpeqd    xmm2, xmm0, xmm0
                        vmovdqa     xmm1, [cons$int4.newvi]
                        vpgatherdd  xmm0, [rsp+x01*4+$00], xmm2
                        __pop       $03
        }

        macro newvi8 {
                        mov         dword [rsp+$04], dsc0
                        vpcmpeqd    ymm2, ymm0, ymm0
                        vmovdqa     ymm1, [cons$int8.newvi]
                        vpgatherdd  ymm0, [rsp+y01*4+$00], ymm2
                        __pop       $07
        }

        macro newvl2 {
                        vmovq       xmm0, qsc0
                        vmovq       xmm1, [rsp+$00]
                        vpslldq     xmm0, xmm0, $08
                        vpor        xmm0, xmm0, xmm1
                        __pop       $01
        }

        macro newvl4 {
                        mov         qword [rsp+$08], qsc0
                        vpcmpeqq    ymm2, ymm0, ymm0
                        vmovdqa     xmm1, [cons$int4.newvl]
                        vpgatherdq  ymm0, [rsp+x01*8+$00], ymm2
                        __pop       $03
        }

        macro newvl8 {
                        mov         qword [rsp+$08], qsc0
                        vpcmpeqq    msk1, zmm0, zmm0
                        vmovdqa     ymm1, [cons$int8.newvl]
                        vpgatherdq  zmm0\{k1\}, [rsp+y01*8+$00]
                        __pop       $07
        }
    ; </fold>

    ; <fold первые (N–1) операндов — на стаке, последний операнд — на аккумуляторе, результат — на стаке>
        macro newvd2_p {
                        vmovq       qword [rsp+$08], xmm0
        }

        macro newvd4_p {
                        vmovq       qword [rsp+$08], xmm0
                        vpcmpeqq    ymm2, ymm0, ymm0
                        vmovdqa     xmm1, [cons$int4.newvd]
                        vpgatherdq  ymm0, [rsp+x01*8+$00], ymm2
                        vmovdqu     yword [rsp+$10], ymm0
                        __sttag_y   $01,  TAG_DOUBLE4
                        __pop       $01
        }

        macro newvd8_p {
                        vmovq       qword [rsp+$08], xmm0
                        vpcmpeqq    msk1, zmm0, zmm0
                        vmovdqa     ymm1, [cons$int8.newvd]
                        vpgatherdq  zmm0\{k1\}, [rsp+y01*8+$00]
                        vmovdqu64   zword [rsp+$30], zmm0
                        __sttag_z   $03,  TAG_DOUBLE8
                        __pop       $03
        }

        macro newvf2_p {
                        vmovd       dword [rsp+$04], xmm0
        }

        macro newvf4_p {
                        vmovd       dword [rsp+$04], xmm0
                        vpcmpeqd    xmm2, xmm0, xmm0
                        vmovdqa     xmm1, [cons$int4.newvf]
                        vpgatherdd  xmm0, [rsp+x01*4+$00], xmm2
                        vmovdqa     xword [rsp+$20], xmm0
                        __pop       $02
        }

        macro newvf8_p {
                        vmovd       dword [rsp+$04], xmm0
                        vpcmpeqd    ymm2, ymm0, ymm0
                        vmovdqa     ymm1, [cons$int8.newvf]
                        vpgatherdd  ymm0, [rsp+y01*4+$00], ymm2
                        vmovdqu     yword [rsp+$50], ymm0
                        __sttag_y   $05,  TAG_FLOAT8
                        __pop       $05
        }

        macro newvb2_p {
                        mov         word  [rsp+$02], $00
                        mov         byte  [rsp+$01], bsc0
        }

        macro newvb4_p {
                        mov         byte  [rsp+$23], bsc0
            repeat(2)
                            mov         bsc0, [rsp+(%-1)*$10]
                            mov         byte  [rsp+(3-%)*1+$20], bsc0
            end repeat
                        __pop       $02
        }

        macro newvb8_p {
                        mov         byte  [rsp+$67], bsc0
            repeat(6)
                            mov         bsc0, [rsp+(%-1)*$10]
                            mov         byte  [rsp+(7-%)*1+$60], bsc0
            end repeat
                        __pop       $06
        }

        macro newvs2_p {
                        mov         word  [rsp+$02], wsc0
        }

        macro newvs4_p {
                        mov         word  [rsp+$26], wsc0
            repeat(2)
                            mov         wsc0, [rsp+(%-1)*$10]
                            mov         word  [rsp+(3-%)*2+$20], wsc0
            end repeat
                        __pop       $02
        }

        macro newvs8_p {
                        mov         word  [rsp+$6e], wsc0
            repeat(6)
                            mov         wsc0, [rsp+(%-1)*$10]
                            mov         word  [rsp+(7-%)*2+$60], wsc0
            end repeat
                        __pop       $06
        }

        macro newvi2_p {
                        mov         dword [rsp+$04], dsc0
        }

        macro newvi4_p {
                        mov         dword [rsp+$04], dsc0
                        vpcmpeqd    xmm2, xmm0, xmm0
                        vmovdqa     xmm1, [cons$int4.newvi]
                        vpgatherdd  xmm0, [rsp+x01*4+$00], xmm2
                        vmovdqa     xword [rsp+$20], xmm0
                        __pop       $02
        }

        macro newvi8_p {
                        mov         dword [rsp+$04], dsc0
                        vpcmpeqd    ymm2, ymm0, ymm0
                        vmovdqa     ymm1, [cons$int8.newvi]
                        vpgatherdd  ymm0, [rsp+y01*4+$00], ymm2
                        vmovdqu     yword [rsp+$50], ymm0
                        __sttag_y   $05,  TAG_INT8
                        __pop       $05
        }

        macro newvl2_p {
                        mov         qword [rsp+$08], qsc0
        }

        macro newvl4_p {
                        mov         qword [rsp+$08], qsc0
                        vpcmpeqq    ymm2, ymm0, ymm0
                        vmovdqa     xmm1, [cons$int4.newvl]
                        vpgatherdq  ymm0, [rsp+x01*8+$00], ymm2
                        vmovdqu     yword [rsp+$10], ymm0
                        __sttag_y   $01,  TAG_LONG4
                        __pop       $01
        }

        macro newvl8_p {
                        mov         qword [rsp+$08], qsc0
                        vpcmpeqq    msk1, zmm0, zmm0
                        vmovdqa     ymm1, [cons$int8.newvl]
                        vpgatherdq  zmm0\{k1\}, [rsp+y01*8+$00]
                        vmovdqu64   zword [rsp+$30], zmm0
                        __sttag_z   $03,  TAG_LONG8
                        __pop       $03
        }
    ; </fold>
; </fold>