;
; Исходный код среды исполнения ПВТ-ОО.
;
; Этот исходный код является частью проекта ПВТ-ОО.
;
; Copyright © 2021 Малик Разработчик
;
; Это свободная программа: вы можете перераспространять её и/или
; изменять её на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
; в каком она была опубликована Фондом свободного программного обеспечения;
; либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.
;
; Эта программа распространяется в надежде, что она может быть полезна,
; но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
; или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЁННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
; общественной лицензии GNU.
;
; Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
; вместе с этой программой. Если это не так, см.
; <http://www.gnu.org/licenses/>.
;
; <fold avt.lang.Array (natives)>
method avt.lang.Array$indexOf$boolean$boolean.01d$int$int$, \
value, boolean, \
array, boolean.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
mempty ; Такой же код, как и для byte[]. Не перемещайте этот блок кода!
; </fold>
method avt.lang.Array$indexOf$int$byte.01d$int$int$, \
value, int, \
array, byte.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_INT ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+byte.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, $00
jge @F
xor rdx, rdx
@@: cmp rdx, rcx
jl @F
mov eax, -$01
jmp .L.RET
@@: sub rcx, rdx
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: movsx rax, byte[.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+byte.01d$fldOffset] ;
lea rdi, [rsi+rdx*1] ;
cld
repne scasb ;
je @F
mov eax, -$01
jmp .L.RET
@@: lea rax, [rdi-$01] ;
sub rax, rsi
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$indexOf$int$char.01d$int$int$, \
value, int, \
array, char.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
mempty ; Такой же код, как и для short[]. Не перемещайте этот блок кода!
; </fold>
method avt.lang.Array$indexOf$int$short.01d$int$int$, \
value, int, \
array, short.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_INT ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+short.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, $00
jge @F
xor rdx, rdx
@@: cmp rdx, rcx
jl @F
mov eax, -$01
jmp .L.RET
@@: sub rcx, rdx
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: movsx rax, word[.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+short.01d$fldOffset] ;
lea rdi, [rsi+rdx*2] ;
cld
repne scasw ;
je @F
mov eax, -$01
jmp .L.RET
@@: lea rax, [rdi-$02] ;
sub rax, rsi
sar rax, $01 ;
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$indexOf$int$int.01d$int$int$, \
value, int, \
array, int.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_INT ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+int.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, $00
jge @F
xor rdx, rdx
@@: cmp rdx, rcx
jl @F
mov eax, -$01
jmp .L.RET
@@: sub rcx, rdx
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: movsxd rax, [.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+int.01d$fldOffset] ;
lea rdi, [rsi+rdx*4] ;
cld
repne scasd ;
je @F
mov eax, -$01
jmp .L.RET
@@: lea rax, [rdi-$04] ;
sub rax, rsi
sar rax, $02 ;
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$indexOf$long$long.01d$int$int$, \
value, long, \
array, long.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_LONG ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+long.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, $00
jge @F
xor rdx, rdx
@@: cmp rdx, rcx
jl @F
mov eax, -$01
jmp .L.RET
@@: sub rcx, rdx
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: mov rax, [.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+long.01d$fldOffset] ;
lea rdi, [rsi+rdx*8] ;
cld
repne scasq ;
je @F
mov eax, -$01
jmp .L.RET
@@: lea rax, [rdi-$08] ;
sub rax, rsi
sar rax, $03 ;
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$indexOf$avt.lang.Object$avt.lang.Object.01d$int$int$, \
value, avt.lang.Object, \
array, avt.lang.Object.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_OBJECT ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+avt.lang.Object.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, $00
jge @F
xor rdx, rdx
@@: cmp rdx, rcx
jl @F
mov eax, -$01
jmp .L.RET
@@: sub rcx, rdx
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: mov rax, [.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+avt.lang.Object.01d$fldOffset] ;
lea rdi, [rsi+rdx*8] ;
cld
repne scasq ;
je @F
mov eax, -$01
jmp .L.RET
@@: lea rax, [rdi-$08] ;
sub rax, rsi
sar rax, $03 ;
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$lastIndexOf$boolean$boolean.01d$int$int$, \
value, boolean, \
array, boolean.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
mempty ; Такой же код, как и для byte[]. Не перемещайте этот блок кода!
; </fold>
method avt.lang.Array$lastIndexOf$int$byte.01d$int$int$, \
value, int, \
array, byte.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_INT ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+byte.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, rcx
jl @F
lea rdx, [rcx-$01]
@@: cmp rdx, $00
jge @F
mov eax, -$01
jmp .L.RET
@@: lea rcx, [rdx+$01]
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: movsx rax, byte[.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+byte.01d$fldOffset] ;
lea rdi, [rsi+rdx*1] ;
std
repne scasb ;
je @F
mov eax, -$01
jmp .L.000
@@: lea rax, [rdi+$01] ;
sub rax, rsi
.L.000: cld
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$lastIndexOf$int$char.01d$int$int$, \
value, int, \
array, char.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
mempty ; Такой же код, как и для short[]. Не перемещайте этот блок кода!
; </fold>
method avt.lang.Array$lastIndexOf$int$short.01d$int$int$, \
value, int, \
array, short.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_INT ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+short.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, rcx
jl @F
lea rdx, [rcx-$01]
@@: cmp rdx, $00
jge @F
mov eax, -$01
jmp .L.RET
@@: lea rcx, [rdx+$01]
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: movsx rax, word[.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+short.01d$fldOffset] ;
lea rdi, [rsi+rdx*2] ;
std
repne scasw ;
je @F
mov eax, -$01
jmp .L.000
@@: lea rax, [rdi+$02] ;
sub rax, rsi
sar rax, $01 ;
.L.000: cld
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$lastIndexOf$int$int.01d$int$int$, \
value, int, \
array, int.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_INT ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+int.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, rcx
jl @F
lea rdx, [rcx-$01]
@@: cmp rdx, $00
jge @F
mov eax, -$01
jmp .L.RET
@@: lea rcx, [rdx+$01]
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: movsxd rax, [.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+int.01d$fldOffset] ;
lea rdi, [rsi+rdx*4] ;
std
repne scasd ;
je @F
mov eax, -$01
jmp .L.000
@@: lea rax, [rdi+$04] ;
sub rax, rsi
sar rax, $02 ;
.L.000: cld
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$lastIndexOf$long$long.01d$int$int$, \
value, long, \
array, long.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_LONG ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+long.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, rcx
jl @F
lea rdx, [rcx-$01]
@@: cmp rdx, $00
jge @F
mov eax, -$01
jmp .L.RET
@@: lea rcx, [rdx+$01]
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: mov rax, [.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+long.01d$fldOffset] ;
lea rdi, [rsi+rdx*8] ;
std
repne scasq ;
je @F
mov eax, -$01
jmp .L.000
@@: lea rax, [rdi+$08] ;
sub rax, rsi
sar rax, $03 ;
.L.000: cld
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$lastIndexOf$avt.lang.Object$avt.lang.Object.01d$int$int$, \
value, avt.lang.Object, \
array, avt.lang.Object.01d, \
startFromIndex, int, \
maximumScanLength, int ; returns int <fold >
menter
lverify value, TAG_OBJECT ;
lverify array, TAG_OBJECT
lverify startFromIndex, TAG_INT
lverify maximumScanLength, TAG_INT
mov rdi, [.array]
test rdi, rdi
jnz @F
mov eax, -$01
jmp .L.RET
@@: movsxd rcx, [rdi+avt.lang.Object.01d$fldLength] ;
movsxd rdx, [.startFromIndex]
cmp rdx, rcx
jl @F
lea rdx, [rcx-$01]
@@: cmp rdx, $00
jge @F
mov eax, -$01
jmp .L.RET
@@: lea rcx, [rdx+$01]
movsxd rsi, [.maximumScanLength]
cmp rsi, $00
jle @F
cmp rsi, rcx
jge @F
mov rcx, rsi
@@: mov rax, [.value] ;
lea rsi, [rdi+$40]
add rsi, [rdi+avt.lang.Object.01d$fldOffset] ;
lea rdi, [rsi+rdx*8] ;
std
repne scasq ;
je @F
mov eax, -$01
jmp .L.000
@@: lea rax, [rdi+$08] ;
sub rax, rsi
sar rax, $03 ;
.L.000: cld
.L.RET: call inst$ipush
mleaved
eleave
; </fold>
method avt.lang.Array$fillByByte$long$int$byte8$int$, \
dst, long, \
cnt, int, \
val, byte8, \
cap, int ; <fold >
menter
lverify dst, TAG_LONG
lverify cnt, TAG_INT
lverify val, TAG_BYTE8
lverify cap, TAG_INT
mov rax, [.val]
mov rdi, [.dst]
movsxd rcx, [.cnt]
movsxd rdx, [.cap]
cmp rdx, $01
je .L.000
cmp rdx, $02
je .L.001
cmp rdx, $04
je .L.002
cmp rdx, $08
je .L.003
jmp .L.RET
.L.000: cld
rep stosb
jmp .L.RET
.L.001: cld
rep stosw
jmp .L.RET
.L.002: cld
rep stosd
jmp .L.RET
.L.003: cld
rep stosq
.L.RET: mleave
eleave
; </fold>
method avt.lang.Array$fillByShort$long$int$short8$int$, \
dst, long, \
cnt, int, \
val, short8, \
cap, int ; <fold >
menter
lverify dst, TAG_LONG
lverify cnt, TAG_INT
lverify val, TAG_SHORT8
lverify cap, TAG_INT
vmovdqa xmm0, [.val]
mov rax, [.val]
mov rdi, [.dst]
movsxd rcx, [.cnt]
movsxd rdx, [.cap]
cmp rdx, $01
je .L.000
cmp rdx, $02
je .L.001
cmp rdx, $04
je .L.002
cmp rdx, $08
je .L.003
jmp .L.RET
.L.000: cld
rep stosw
jmp .L.RET
.L.001: cld
rep stosd
jmp .L.RET
.L.002: cld
rep stosq
jmp .L.RET
.L.003: vmovdqu xword[rdi], xmm0
lea rdi, [rdi+$10]
loop .L.003
.L.RET: mleave
eleave
; </fold>
method avt.lang.Array$fillByInt$long$int$int8$int$, \
dst, long, \
cnt, int, \
val, int8, \
cap, int ; <fold >
menter
lverify dst, TAG_LONG
lverify cnt, TAG_INT
lverify val, TAG_INT8
lverify cap, TAG_INT
vmovdqu ymm0, [.val]
mov rax, [.val]
mov rdi, [.dst]
movsxd rcx, [.cnt]
movsxd rdx, [.cap]
cmp rdx, $01
je .L.000
cmp rdx, $02
je .L.001
cmp rdx, $04
je .L.002
cmp rdx, $08
je .L.003
jmp .L.RET
.L.000: cld
rep stosd
jmp .L.RET
.L.001: cld
rep stosq
jmp .L.RET
.L.002: vmovdqu xword[rdi], xmm0
lea rdi, [rdi+$10]
loop .L.002
jmp .L.RET
.L.003: vmovdqu yword[rdi], ymm0
lea rdi, [rdi+$20]
loop .L.003
.L.RET: mleave
eleave
; </fold>
method avt.lang.Array$fillByLong$long$int$long8$int$, \
dst, long, \
cnt, int, \
val, long8, \
cap, int ; <fold >
menter
lverify dst, TAG_LONG
lverify cnt, TAG_INT
lverify val, TAG_LONG8
lverify cap, TAG_INT
vmovdqu64 zmm0, [.val]
mov rax, [.val]
mov rdi, [.dst]
movsxd rcx, [.cnt]
movsxd rdx, [.cap]
cmp rdx, $01
je .L.000
cmp rdx, $02
je .L.001
cmp rdx, $04
je .L.002
cmp rdx, $08
je .L.003
jmp .L.RET
.L.000: cld
rep stosq
jmp .L.RET
.L.001: vmovdqu xword[rdi], xmm0
lea rdi, [rdi+$10]
loop .L.001
jmp .L.RET
.L.002: vmovdqu yword[rdi], ymm0
lea rdi, [rdi+$20]
loop .L.002
jmp .L.RET
.L.003: vmovdqu64 zword[rdi], zmm0
lea rdi, [rdi+$40]
loop .L.003
.L.RET: mleave
eleave
; </fold>
method avt.lang.Array$fillByFloat$long$int$float8$int$, \
dst, long, \
cnt, int, \
val, float8, \
cap, int ; <fold >
menter
lverify dst, TAG_LONG
lverify cnt, TAG_INT
lverify val, TAG_FLOAT8
lverify cap, TAG_INT
vmovdqu ymm0, [.val]
mov rax, [.val]
mov rdi, [.dst]
movsxd rcx, [.cnt]
movsxd rdx, [.cap]
cmp rdx, $01
je .L.000
cmp rdx, $02
je .L.001
cmp rdx, $04
je .L.002
cmp rdx, $08
je .L.003
jmp .L.RET
.L.000: cld
rep stosd
jmp .L.RET
.L.001: cld
rep stosq
jmp .L.RET
.L.002: vmovdqu xword[rdi], xmm0
lea rdi, [rdi+$10]
loop .L.002
jmp .L.RET
.L.003: vmovdqu yword[rdi], ymm0
lea rdi, [rdi+$20]
loop .L.003
.L.RET: mleave
eleave
; </fold>
method avt.lang.Array$fillByDouble$long$int$double8$int$, \
dst, long, \
cnt, int, \
val, double8, \
cap, int ; <fold >
menter
lverify dst, TAG_LONG
lverify cnt, TAG_INT
lverify val, TAG_DOUBLE8
lverify cap, TAG_INT
vmovdqu64 zmm0, [.val]
mov rax, [.val]
mov rdi, [.dst]
movsxd rcx, [.cnt]
movsxd rdx, [.cap]
cmp rdx, $01
je .L.000
cmp rdx, $02
je .L.001
cmp rdx, $04
je .L.002
cmp rdx, $08
je .L.003
jmp .L.RET
.L.000: cld
rep stosq
jmp .L.RET
.L.001: vmovdqu xword[rdi], xmm0
lea rdi, [rdi+$10]
loop .L.001
jmp .L.RET
.L.002: vmovdqu yword[rdi], ymm0
lea rdi, [rdi+$20]
loop .L.002
jmp .L.RET
.L.003: vmovdqu64 zword[rdi], zmm0
lea rdi, [rdi+$40]
loop .L.003
.L.RET: mleave
eleave
; </fold>
method avt.lang.Array$fillByReal$long$int$real$, \
dst, long, \
cnt, int, \
val, real ; <fold >
menter
lverify dst, TAG_LONG
lverify cnt, TAG_INT
lverify val, TAG_REAL
fld tbyte[.val]
mov rdi, [.dst]
movsxd rcx, [.cnt]
.L.000: fld st0
fstp tbyte[rdi]
lea rdi, [rdi+$0a]
loop .L.000
ffree st0
fincstp
mleave
eleave
; </fold>
method avt.lang.Array$fillByRef$long$int$avt.lang.Object$, \
dst, long, \
cnt, int, \
val, avt.lang.Object ; <fold >
menter
lverify dst, TAG_LONG
lverify cnt, TAG_INT
lverify val, TAG_OBJECT
mov rax, [.val]
mov rdi, [.dst]
movsxd rcx, [.cnt]
test rax, rax
jz @F
lock add qword[rax+avt.lang.Object$fldRefCountFromObjects], rcx
@@: cld
.L.000: mov rdx, [rdi]
test rdx, rdx
jz @F
lock dec qword[rdx+avt.lang.Object$fldRefCountFromObjects]
@@: stosq
loop .L.000
mleave
eleave
; </fold>
method avt.lang.Array$copyForwardByByte$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
cld
rep movsb
mleave
eleave
; </fold>
method avt.lang.Array$copyForwardByShort$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
cld
rep movsw
mleave
eleave
; </fold>
method avt.lang.Array$copyForwardByInt$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
cld
rep movsd
mleave
eleave
; </fold>
method avt.lang.Array$copyForwardByLong$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
cld
rep movsq
mleave
eleave
; </fold>
method avt.lang.Array$copyForwardByRef$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
cld
.L.000: lodsq
test rax, rax
jz @F
lock inc qword[rax+avt.lang.Object$fldRefCountFromObjects]
@@: mov rdx, [rdi]
test rdx, rdx
jz @F
lock dec qword[rdx+avt.lang.Object$fldRefCountFromObjects]
@@: stosq
loop .L.000
mleave
eleave
; </fold>
method avt.lang.Array$copyBackwardByByte$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
std
rep movsb
cld
mleave
eleave
; </fold>
method avt.lang.Array$copyBackwardByShort$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
std
rep movsw
cld
mleave
eleave
; </fold>
method avt.lang.Array$copyBackwardByInt$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
std
rep movsd
cld
mleave
eleave
; </fold>
method avt.lang.Array$copyBackwardByLong$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
std
rep movsq
cld
mleave
eleave
; </fold>
method avt.lang.Array$copyBackwardByRef$long$long$long$, \
src, long, \
dst, long, \
cnt, long ; <fold >
menter
lverify src, TAG_LONG
lverify dst, TAG_LONG
lverify cnt, TAG_LONG
mov rsi, [.src]
mov rdi, [.dst]
mov rcx, [.cnt]
std
.L.000: lodsq
test rax, rax
jz @F
lock inc qword[rax+avt.lang.Object$fldRefCountFromObjects]
@@: mov rdx, [rdi]
test rdx, rdx
jz @F
lock dec qword[rdx+avt.lang.Object$fldRefCountFromObjects]
@@: stosq
loop .L.000
cld
mleave
eleave
; </fold>
method avt.lang.Array$getArrayPointer$avt.lang.array.Measureable$, \
array, avt.lang.array.Measureable ; returns long <fold >
menter
lverify array, TAG_OBJECT
mov r1, [.array]
lea r0, [r1+$40]
add r0, [r1+avt.lang.Object.01d$fldOffset]
call inst$lpush
mleaveq
eleave
; </fold>
; </fold>
