instruction.getarrayelement.inc

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

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

; <fold read array element>
    if(used inst$getarrayelementi) ; <fold >
        inst getarrayelementi
                    averify int
                    mov     ecx, [rax+rdi*4]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    mov     qword[rsp+$18], $00
                    mov     qword[rsp+$10], rcx
                    pop1set TAG_INT
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementi2) ; <fold >
        inst getarrayelementi2
                    averify int2
                    lea     rdi, [rdi+rdi*1]
                    vmovq   xmm0, [rax+rdi*4]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_INT2
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementi4) ; <fold >
        inst getarrayelementi4
                    averify int4
                    lea     rdi, [rdi*4]
                    vmovdqu xmm0, [rax+rdi*4]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_INT4
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementi8) ; <fold >
        inst getarrayelementi8
                    averify int8
                    lea     rdi, [rdi*8]
                    vmovdqu ymm0, [rax+rdi*4]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqu yword[rsp], ymm0
                    set     TAG_INT8
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementl) ; <fold >
        inst getarrayelementl
                    averify long
                    mov     rcx, [rax+rdi*8]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    mov     qword[rsp+$18], $00
                    mov     qword[rsp+$10], rcx
                    pop1set TAG_LONG
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementl2) ; <fold >
        inst getarrayelementl2
                    averify long2
                    lea     rdi, [rdi+rdi*1]
                    vmovdqu xmm0, [rax+rdi*8]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_LONG2
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementl4) ; <fold >
        inst getarrayelementl4
                    averify long4
                    lea     rdi, [rdi*4]
                    vmovdqu ymm0, [rax+rdi*8]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqu yword[rsp], ymm0
                    set     TAG_LONG4
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementl8) ; <fold >
        inst getarrayelementl8
                    averifyz long8
                    lea     rdi, [rdi*8]
                    vmovdqu64 zmm0, [rax+rdi*8]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqu64 zword[rsp], zmm0
                    set     TAG_LONG8
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementf) ; <fold >
        inst getarrayelementf
                    averify float
                    vmovd   xmm0, [rax+rdi*4]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_FLOAT
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementf2) ; <fold >
        inst getarrayelementf2
                    averify float2
                    lea     rdi, [rdi+rdi*1]
                    vmovq   xmm0, [rax+rdi*4]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_FLOAT2
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementf4) ; <fold >
        inst getarrayelementf4
                    averify float4
                    lea     rdi, [rdi*4]
                    vmovdqu xmm0, [rax+rdi*4]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_FLOAT4
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementf8) ; <fold >
        inst getarrayelementf8
                    averify float8
                    lea     rdi, [rdi*8]
                    vmovdqu ymm0, [rax+rdi*4]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqu yword[rsp], ymm0
                    set     TAG_FLOAT8
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementd) ; <fold >
        inst getarrayelementd
                    averify double
                    vmovq   xmm0, [rax+rdi*8]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_DOUBLE
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementd2) ; <fold >
        inst getarrayelementd2
                    averify double2
                    lea     rdi, [rdi+rdi*1]
                    vmovdqu xmm0, [rax+rdi*8]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_DOUBLE2
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementd4) ; <fold >
        inst getarrayelementd4
                    averify double4
                    lea     rdi, [rdi*4]
                    vmovdqu ymm0, [rax+rdi*8]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqu yword[rsp], ymm0
                    set     TAG_DOUBLE4
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementd8) ; <fold >
        inst getarrayelementd8
                    averifyz double8
                    lea     rdi, [rdi*8]
                    vmovdqu64 zmm0, [rax+rdi*8]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqu64 zword[rsp], zmm0
                    set     TAG_DOUBLE8
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementb) ; <fold >
        inst getarrayelementb
                    averify byte
                    movsx   ecx, byte[rax+rdi*1]
                    vmovd   xmm0, ecx
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_INT
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementb2) ; <fold >
        inst getarrayelementb2
                    averify byte2
                    lea     rdi, [rdi+rdi*1]
                    movzx   ecx, word[rax+rdi*1]
                    vmovd   xmm0, ecx
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_BYTE2
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementb4) ; <fold >
        inst getarrayelementb4
                    averify byte4
                    lea     rdi, [rdi*4]
                    vmovd   xmm0, [rax+rdi*1]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_BYTE4
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementb8) ; <fold >
        inst getarrayelementb8
                    averify byte8
                    lea     rdi, [rdi*8]
                    vmovq   xmm0, [rax+rdi*1]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_BYTE8
        end_inst
    end if ; </fold>

    if(used inst$getarrayelements) ; <fold >
        inst getarrayelements
                    averify short
                    movsx   ecx, word[rax+rdi*2]
                    vmovd   xmm0, ecx
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_INT
        end_inst
    end if ; </fold>

    if(used inst$getarrayelements2) ; <fold >
        inst getarrayelements2
                    averify short2
                    lea     rdi, [rdi+rdi*1]
                    vmovd   xmm0, [rax+rdi*2]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_SHORT2
        end_inst
    end if ; </fold>

    if(used inst$getarrayelements4) ; <fold >
        inst getarrayelements4
                    averify short4
                    lea     rdi, [rdi*4]
                    vmovq   xmm0, [rax+rdi*2]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_SHORT4
        end_inst
    end if ; </fold>

    if(used inst$getarrayelements8) ; <fold >
        inst getarrayelements8
                    averify short8
                    lea     rdi, [rdi*8]
                    vmovdqu xmm0, [rax+rdi*2]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_SHORT8
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementx) ; <fold >
        inst getarrayelementx
                    averify real
                    lea     rdi, [rdi+rdi*4]
                    fld     tbyte[rax+rdi*2]
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    mov     dword[rsp+$1c], $00
                    mov     word[rsp+$1a], $00
                    fstp    tbyte[rsp+$10]
                    pop1set TAG_REAL
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementc) ; <fold >
        inst getarrayelementc
                    averify char
                    movzx   ecx, word[rax+rdi*2]
                    vmovd   xmm0, ecx
                    lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    vmovdqa xword[rsp+$10], xmm0
                    pop1set TAG_INT
        end_inst
    end if ; </fold>

    if(used inst$getarrayelementr) ; <fold >
        inst getarrayelementr
                    averify avt.lang.Object
                    mov     rcx, [rax+rdi*8]
                    test    rcx, rcx
                    jz      @F
                    lock inc qword[rcx+avt.lang.Object$fldRefCountFromOthers]
            @@:     lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
                    mov     qword[rsp+$18], $00
                    mov     qword[rsp+$10], rcx
                    pop1set TAG_OBJECT
        end_inst
    end if ; </fold>
; </fold>