Runtime.inc

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

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

; <fold avt.lang.Runtime — родной код>
    if(used avt.lang.Runtime$addOtherRefInInstance$avt.lang.Object$avt.security.CallerSecurityContext$) ; <fold >
                    method      avt.lang.Runtime$addOtherRefInInstance$avt.lang.Object$avt.security.CallerSecurityContext$, \
                                instance, avt.lang.Object, \
                                context, avt.security.CallerSecurityContext
                    menter      $01
                    test        qword [.context], -$01
                    jnz         .L.0000
                    invstat     avt.lang.Thread$callerTypeTrace$
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.lang.Class$
                    jmp         .L.0001
        .L.0000:    loadr_l     context
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.security.CallerSecurityContext$
        .L.0001:    mov         r00q, [.instance]
                    tstincrcoth r00q
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.lang.Runtime$releaseRefsInInstance$long$avt.security.CallerSecurityContext$) ; <fold >
                    method      avt.lang.Runtime$releaseRefsInInstance$long$avt.security.CallerSecurityContext$, \
                                instancePointer, long, \
                                context, avt.security.CallerSecurityContext
                    menter      $01
                    test        qword [.context], -$01
                    jnz         .L.0000
                    invstat     avt.lang.Thread$callerTypeTrace$
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.lang.Class$
                    jmp         .L.0001
        .L.0000:    loadr_l     context
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.security.CallerSecurityContext$
        .L.0001:    mov         r08q, [.instancePointer]
                    lea         r02q, [r08+$00]
                    add         r02q, [r08+avt.lang.Object$fldClassOffset]
                    mov         r01q, [r02+avt.lang.Class$fldComponentTypeOffset]
                    test        r01q, r01q
                    jz          .L.0004
                    lea         r01q, [r02+r01*1+$00]
                    test        dword [r01+avt.lang.ReflectiveObject$fldAttributes], avt.lang.Class$PRIMITIVE
                    jnz         .L.0004
                    mov         r01d, [r08+avt.lang.Array$fldCapacity]
                    and         r01d, $7fffffff
                    lea         r09q, [r08+avt.lang.Array$fldOffset+$08]
                    add         r09q, [r08+avt.lang.Array$fldOffset+$00]
                    jmp         .L.0003
        .L.0002:    mov         r00q, [r09+r01*8+$00]
                    tstdecrcobj r00q
        .L.0003:    sub         r01d, $01
                    jge         .L.0002
        .L.0004:    mov         r09d, [r02+avt.lang.Class$fldInstanceReferencedFieldsOffset]
                    mov         r01d, [r02+avt.lang.Class$fldInstanceReferencedFieldsCount]
                    lea         r02q, [r02+r09*1+$00]
                    jmp         .L.0006
        .L.0005:    movsxd      r09q, [r02+r01*4+$00]
                    mov         r00q, [r08+r09*1+$00]
                    tstdecrcobj r00q
        .L.0006:    sub         r01d, $01
                    jge         .L.0005
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.lang.Runtime$toPointer$avt.lang.Object$) ; <fold returns long>
                    fast        avt.lang.Runtime$toPointer$avt.lang.Object$, \
                                instance, avt.lang.Object
                    fenter
                    mov         r00q, [.instance]
                    tstdecrcoth r00q
                    fcltag_x    instance
                    fleave
    end if ; </fold>

    if(used avt.lang.Runtime$refsFromInstance$long$long$avt.security.CallerSecurityContext$) ; <fold returns long>
                    method      avt.lang.Runtime$refsFromInstance$long$long$avt.security.CallerSecurityContext$, \
                                instancePointer, long, \
                                targetPointer, long, \
                                context, avt.security.CallerSecurityContext
                    menter      $01
                    test        qword [.context], -$01
                    jnz         .L.0000
                    invstat     avt.lang.Thread$callerTypeTrace$
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.lang.Class$
                    jmp         .L.0001
        .L.0000:    loadr_l     context
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.security.CallerSecurityContext$
        .L.0001:    xor         r00q, r00q
                    mov         r08q, [.instancePointer]
                    lea         r02q, [r08+$00]
                    add         r02q, [r08+avt.lang.Object$fldClassOffset]
                    mov         r01q, [r02+avt.lang.Class$fldComponentTypeOffset]
                    test        r01q, r01q
                    jz          .L.0004
                    lea         r01q, [r02+r01*1+$00]
                    test        dword [r01+avt.lang.ReflectiveObject$fldAttributes], avt.lang.Class$PRIMITIVE
                    jnz         .L.0004
                    mov         r01d, [r08+avt.lang.Array$fldCapacity]
                    and         r01d, $7fffffff
                    lea         r09q, [r08+avt.lang.Array$fldOffset+$08]
                    add         r09q, [r08+avt.lang.Array$fldOffset+$00]
                    jmp         .L.0003
        .L.0002:    mov         r10q, [r09+r01*8+$00]
                    cmp         r10q, [.targetPointer]
                    jne         .L.0003
                    lea         r00q, [r00+$01]
        .L.0003:    sub         r01d, $01
                    jge         .L.0002
        .L.0004:    mov         r09d, [r02+avt.lang.Class$fldInstanceReferencedFieldsOffset]
                    mov         r01d, [r02+avt.lang.Class$fldInstanceReferencedFieldsCount]
                    lea         r02q, [r02+r09*1+$00]
                    jmp         .L.0006
        .L.0005:    movsxd      r09q, [r02+r01*4+$00]
                    mov         r10q, [r08+r09*1+$00]
                    cmp         r10q, [.targetPointer]
                    jne         .L.0006
                    lea         r00q, [r00+$01]
        .L.0006:    sub         r01d, $01
                    jge         .L.0005
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.lang.Runtime$refsToInstance$long$avt.security.CallerSecurityContext$) ; <fold returns long2>
                    method      avt.lang.Runtime$refsToInstance$long$avt.security.CallerSecurityContext$, \
                                instancePointer, long, \
                                context, avt.security.CallerSecurityContext
                    menter      $01
                    test        qword [.context], -$01
                    jnz         .L.0000
                    invstat     avt.lang.Thread$callerTypeTrace$
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.lang.Class$
                    jmp         .L.0001
        .L.0000:    loadr_l     context
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.security.CallerSecurityContext$
        .L.0001:    mov         r00q, [.instancePointer]
                    vmovdqa     xmm0, [r00+avt.lang.Object$fldRefCountFromOthers]
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.lang.Runtime$toMemoryRegionPointers$long$long$) ; <fold returns long2>
                    fast        avt.lang.Runtime$toMemoryRegionPointers$long$long$, \
                                pointer, long, \
                                size, long
                    fenter
                    mov         r01q, [.pointer]
                    mov         r00q, [.size]
                    lea         r00q, [r01+r00*1+$00]
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r01q
                    vpslldq     xmm0, xmm0, $08
                    vpor        xmm0, xmm0, xmm1
                    fleave
    end if ; </fold>

    if(used avt.lang.Runtime$toMemoryRegionPointers$avt.lang.Object$long$) ; <fold returns long2>
                    fast        avt.lang.Runtime$toMemoryRegionPointers$avt.lang.Object$long$, \
                                instance, avt.lang.Object, \
                                size, long
                    fenter
                    mov         r01q, [.instance]
                    mov         r00q, [.size]
                    lea         r00q, [r01+r00*1+$00]
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r01q
                    vpslldq     xmm0, xmm0, $08
                    vpor        xmm0, xmm0, xmm1
                    tstdecrcoth r01q
                    fcltag_x    instance
                    fleave
    end if ; </fold>

    if(used avt.lang.Runtime$initializeInstance$long$avt.lang.Class$long$int$avt.security.CallerSecurityContext$) ; <fold returns avt.lang.Object>
                    method      avt.lang.Runtime$initializeInstance$long$avt.lang.Class$long$int$avt.security.CallerSecurityContext$, \
                                instancePointer, long, \
                                type, avt.lang.Class, \
                                size, long, \
                                length, int, \
                                context, avt.security.CallerSecurityContext
                    menter      $01
                    test        qword [avt.lang.Runtime$instance], -$01
                    jz          .L.0001
                    test        qword [.context], -$01
                    jnz         .L.0000
                    invstat     avt.lang.Thread$callerTypeTrace$
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.lang.Class$
                    jmp         .L.0001
        .L.0000:    loadr_l     context
                    tpushr
                    invstat     avt.lang.Runtime$checkCaller$avt.security.CallerSecurityContext$
        .L.0001:    savetbp
                    mov         r07q, [.instancePointer]
                    mov         r02q, [.type]
                    mov         r01q, [.size]
                    mov         r00d, [.length]
                    sub         r02q, r07q
                    mov         qword [r07+avt.lang.Object$fldRefCountFromOthers], $01
                    mov         qword [r07+avt.lang.Object$fldRefCountFromObjects], $00
                    mov         qword [r07+avt.lang.Object$fldClassOffset], r02q
                    mov         qword [r07+avt.lang.Object$fldMonitor], null
                    lea         r02q, [r07+$00]
                    cmp         r00d, $00
                    jge         .L.0002
                    lea         r07q, [r07+$20]
                    lea         r01q, [r01-$20]
                    jmp         .L.0003
        .L.0002:    mov         qword [r07+avt.lang.Array$fldLength], r00q
                    mov         qword [r07+avt.lang.Array$fldCapacity], r00q
                    mov         qword [r07+avt.lang.Array$fldParentStruct], null
                    mov         qword [r07+avt.lang.Array$fldOffset], $00
                    lea         r07q, [r07+$40]
                    lea         r01q, [r01-$40]
        .L.0003:    sar         r01q, $03
                    jz          .L.EXIT
                    xor         r00q, r00q
                    cld
                    rep stosq
        .L.EXIT:    lea         r00q, [r02+$00]
                    rstortbp
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.lang.Runtime$readProcessorBrandString$byte.01d$) ; <fold returns int>
                    method      avt.lang.Runtime$readProcessorBrandString$byte.01d$, \
                                dst, byte.01d
                    menter      $00
                    savetp
                    mov         r06q, [.dst]
                    lea         r07q, [r06+avt.lang.Array$fldOffset+$08]
                    add         r07q, [r06+avt.lang.Array$fldOffset+$00]
                    lea         r06q, [r03+$00]
                    mov         r00d, $80000000
                    cpuid
                    test        r00d, $80000000
                    jz          .L.0000
                    cmp         r00d, $80000004
                    jge         .L.0001
        .L.0000:    lea         r03q, [r06+$00]
                    mov         r00d, $00
                    jmp         .L.EXIT
        .L.0001:    mov         r00d, $80000002
                    cpuid
                    mov         dword [r07+$00], r00d
                    mov         dword [r07+$04], r03d
                    mov         dword [r07+$08], r01d
                    mov         dword [r07+$0c], r02d
                    mov         r00d, $80000003
                    cpuid
                    mov         dword [r07+$10], r00d
                    mov         dword [r07+$14], r03d
                    mov         dword [r07+$18], r01d
                    mov         dword [r07+$1c], r02d
                    mov         r00d, $80000004
                    cpuid
                    mov         dword [r07+$20], r00d
                    mov         dword [r07+$24], r03d
                    mov         dword [r07+$28], r01d
                    mov         dword [r07+$2c], r02d
                    lea         r02q, [r07+$00]
                    lea         r03q, [r06+$00]
                    mov         r01d, $30
                    xor         r00d, r00d
                    cld
                    repne scasb
                    je          .L.0002
                    mov         r00d, $30
                    jmp         .L.EXIT
        .L.0002:    lea         r00q, [r07-$01]
                    sub         r00q, r02q
        .L.EXIT:    rstortp
                    mleave
                    eleave
    end if ; </fold>

    if(used avt.lang.Runtime$getProgrammeCodeRegionPointers$) ; <fold returns long2>
                    proc        avt.lang.Runtime$getProgrammeCodeRegionPointers$
                    lea         r00q, [code$begin]
                    lea         r01q, [code$end]
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r01q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    ret
                    end_proc
    end if ; </fold>

    if(used avt.lang.Runtime$getProgrammeDataRegionPointers$) ; <fold returns long2>
                    proc        avt.lang.Runtime$getProgrammeDataRegionPointers$
                    lea         r00q, [data$begin]
                    lea         r01q, [data$end]
                    vmovq       xmm0, r00q
                    vmovq       xmm1, r01q
                    vpslldq     xmm1, xmm1, $08
                    vpor        xmm0, xmm0, xmm1
                    ret
                    end_proc
    end if ; </fold>

    if(used avt.lang.Runtime$toInstance$long$) ; <fold returns avt.lang.Object>
                    fast        avt.lang.Runtime$toInstance$long$, \
                                instancePointer, long
                    fenter
                    mov         r00q, [.instancePointer]
                    tstincrcoth r00q
                    fleave
    end if ; </fold>
; </fold>