Runtime.inc

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

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

; <fold avt.lang.Runtime (natives)>

    method avt.lang.Runtime$invokeMainConstructor$avt.lang.Runtime$, \
                instance, avt.lang.Runtime  ; <fold >
                menter
                rloadloc instance
                dup1
                mov     r0, [.instance]
                add     r0, [r0+avt.lang.Object$fldClassOffset]
                add     r0, [r0+avt.lang.Class$fldMainConstructorOffset]
                invokestatic r0
                invokestatic avt.lang.Runtime$invokeAfterConstruction$avt.lang.Object$
                mleave
                eleave
    ; </fold>

    method avt.lang.Runtime$releaseRefsInInstance$long$, \
                pointer, long  ; <fold >
                menter
                lverify pointer, TAG_LONG
                mov     r0, [.pointer]
                mov     r1, r0
                add     r1, [r0+avt.lang.Object$fldClassOffset]
                mov     r2, [r1+avt.lang.Class$fldComponentTypeOffset]
                test    r2, r2
                jz      .L.002
                lea     r2, [r1+r2*1]
                test    dword[r2+avt.lang.Class$fldModifiers], $80
                jnz     .L.002
                lea     r6, [r0+$40]
                add     r6, [r0+avt.lang.Object.01d$fldOffset]
                movsxd  r2, [r0+avt.lang.Object.01d$fldLength]
                jmp     .L.001
        .L.000: mov     r7, [r6+r2*8]
                test    r7, r7
                jz      .L.001
                lock dec qword[r7+avt.lang.Object$fldRefCountFromObjects]
        .L.001: lea     r2, [r2-$01]
                cmp     r2, $00
                jge     .L.000
        .L.002: movsxd  r2, [r1+avt.lang.Class$fldReferencedFieldsCount]
                movsxd  r6, [r1+avt.lang.Class$fldReferencedFieldsOffset]
                lea     r6, [r1+r6*1]
                jmp     .L.004
        .L.003: movsxd  r7, [r6+r2*4]
                mov     r7, [r0+r7*1]
                test    r7, r7
                jz      .L.004
                lock dec qword[r7+avt.lang.Object$fldRefCountFromObjects]
        .L.004: lea     r2, [r2-$01]
                cmp     r2, $00
                jge     .L.003
                mleave
                eleave
    ; </fold>

    method avt.lang.Runtime$refsFromInstance$long$long$, \
                pointer, long, \
                target, long  ; returns long <fold >
                menter
                lverify pointer, TAG_LONG
                lverify target, TAG_LONG
                bload   $00
                itol
                mov     r0, [.pointer]
                mov     r1, r0
                add     r1, [r0+avt.lang.Object$fldClassOffset]
                mov     r2, [r1+avt.lang.Class$fldComponentTypeOffset]
                test    r2, r2
                jz      .L.002
                lea     r2, [r1+r2*1]
                test    dword[r2+avt.lang.Class$fldModifiers], $80
                jnz     .L.002
                lea     r6, [r0+$40]
                add     r6, [r0+avt.lang.Object.01d$fldOffset]
                movsxd  r2, [r0+avt.lang.Object.01d$fldLength]
                jmp     .L.001
        .L.000: mov     r7, [r6+r2*8]
                cmp     r7, [.target]
                jne     .L.001
                inc     qword[rsp]
        .L.001: lea     r2, [r2-$01]
                cmp     r2, $00
                jge     .L.000
        .L.002: movsxd  r2, [r1+avt.lang.Class$fldReferencedFieldsCount]
                movsxd  r6, [r1+avt.lang.Class$fldReferencedFieldsOffset]
                lea     r6, [r1+r6*1]
                jmp     .L.004
        .L.003: movsxd  r7, [r6+r2*4]
                mov     r7, [r0+r7*1]
                cmp     r7, [.target]
                jne     .L.004
                inc     qword[rsp]
        .L.004: lea     r2, [r2-$01]
                cmp     r2, $00
                jge     .L.003
                mleaveq
                eleave
    ; </fold>

    method avt.lang.Runtime$refsToInstance$long$, \
                pointer, long  ; returns long2 <fold >
                menter
                lverify pointer, TAG_LONG
                mov     r0, [.pointer]
                l2load  [r0]
                mleavex
                eleave
    ; </fold>

    method avt.lang.Runtime$initializeInstance$long$avt.lang.Class$long$int$, \
                pointer, long, \
                type, avt.lang.Class, \
                size, long, \
                length, int  ; returns avt.lang.Object <fold >
                menter
                lverify pointer, TAG_LONG
                lverify type, TAG_OBJECT
                lverify size, TAG_LONG
                lverify length, TAG_INT
                mov     rdi, [.pointer]
                mov     rdx, [.type]
                mov     rcx, [.size]
                movsxd  rax, [.length]
                sub     rdx, rdi
                mov     qword[rdi+avt.lang.Object$fldRefCountFromOthers], $00
                mov     qword[rdi+avt.lang.Object$fldRefCountFromObjects], $00
                mov     qword[rdi+avt.lang.Object$fldClassOffset], rdx
                mov     qword[rdi+avt.lang.Object$fldMonitor], null
                mov     rdx, rdi
                cmp     rax, $00
                jge     .L.000
                lea     rcx, [rcx-$20]
                lea     rdi, [rdi+$20]
                jmp     .L.001
        .L.000: mov     qword[rdi+avt.lang.Object.01d$fldLength], rax
                mov     qword[rdi+avt.lang.Object.01d$fldParentStruct], null
                mov     qword[rdi+avt.lang.Object.01d$fldReserved2], $00
                mov     qword[rdi+avt.lang.Object.01d$fldOffset], $00
                lea     rcx, [rcx-$40]
                lea     rdi, [rdi+$40]
        .L.001: sar     rcx, $03
                jrcxz   .L.002
                xor     rax, rax
                cld
                rep stosq
        .L.002: rload   rdx
                mleaver
                eleave
    ; </fold>

    method avt.lang.Runtime$getInstanceClass$long$, \
                pointer, long  ; returns avt.lang.Class <fold >
                menter
                lverify pointer, TAG_LONG
                mov     r0, [.pointer]
                add     r0, [r0+avt.lang.Object$fldClassOffset]
                call    inst$rpush
                mleaver
                eleave
    ; </fold>

    method avt.lang.Runtime$toInstance$long$, \
                pointer, long  ; returns avt.lang.Object <fold >
                menter
                lverify pointer, TAG_LONG
                rload   [.pointer]
                mleaver
                eleave
    ; </fold>

    method avt.lang.Runtime$isIntersectRegion$avt.lang.Object$long$long$long$, \
                instance, avt.lang.Object, \
                instanceSize, long, \
                beginPointer, long, \
                endPointer, long  ; returns boolean <fold >
                menter
                lverify instance, TAG_OBJECT
                lverify instanceSize, TAG_LONG
                lload   [.instance]
                mov     r0, [.instance]
                add     r0, [.instanceSize]
                call    inst$lpush
                lloadloc beginPointer
                lloadloc endPointer
                invokestaticd avt.lang.Runtime$isIntersectRegion$long$long$long$long$
                mleaved
                eleave
    ; </fold>

    method avt.lang.Runtime$getProcessorBrandString$byte.01d$, \
                dst, byte.01d  ; returns int <fold >
                menter
                lverify dst, TAG_OBJECT
                mov     rsi, [.dst]
                lea     rdi, [rsi+$40]
                add     rdi, [rsi+byte.01d$fldOffset]
                mov     rsi, rbx
                mov     eax, $80000002
                cpuid
                mov     [rdi+$00], eax
                mov     [rdi+$04], ebx
                mov     [rdi+$08], ecx
                mov     [rdi+$0c], edx
                mov     eax, $80000003
                cpuid
                mov     [rdi+$10], eax
                mov     [rdi+$14], ebx
                mov     [rdi+$18], ecx
                mov     [rdi+$1c], edx
                mov     eax, $80000004
                cpuid
                mov     [rdi+$20], eax
                mov     [rdi+$24], ebx
                mov     [rdi+$28], ecx
                mov     [rdi+$2c], edx
                mov     rbx, rsi
                mov     rdx, rdi
                mov     ecx, $30
                xor     eax, eax
                cld
                repne scasb
                je      .L.000
                mov     eax, $30
                jmp     .L.RET
        .L.000: lea     rax, [rdi-$01]
                sub     rax, rdx
        .L.RET: call    inst$ipush
                mleaved
                eleave
    ; </fold>

    method avt.lang.Runtime$getProgrammeCodeRegion$  ; returns long2 <fold >
                menter
                lea     r0, [code$begin]
                call    inst$lpush
                lea     r0, [code$end]
                call    inst$lpush
                newvectorl2
                mleavex
                eleave
    ; </fold>

    method avt.lang.Runtime$getProgrammeDataRegion$  ; returns long2 <fold >
                menter
                lea     r0, [data$begin]
                call    inst$lpush
                lea     r0, [data$end]
                call    inst$lpush
                newvectorl2
                mleavex
                eleave
    ; </fold>
; </fold>