;
; Исходный код среды исполнения ПВТ-ОО.
;
; Этот исходный код является частью проекта ПВТ-ОО.
;
; Copyright © 2021 Малик Разработчик
;
; Это свободная программа: вы можете перераспространять её и/или
; изменять её на условиях Меньшей Стандартной общественной лицензии GNU в том виде,
; в каком она была опубликована Фондом свободного программного обеспечения;
; либо версии 3 лицензии, либо (по вашему выбору) любой более поздней версии.
;
; Эта программа распространяется в надежде, что она может быть полезна,
; но БЕЗО ВСЯКИХ ГАРАНТИЙ; даже без неявной гарантии ТОВАРНОГО ВИДА
; или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЁННЫХ ЦЕЛЕЙ. Подробнее см. в Меньшей Стандартной
; общественной лицензии GNU.
;
; Вы должны были получить копию Меньшей Стандартной общественной лицензии GNU
; вместе с этой программой. Если это не так, см.
; <http://www.gnu.org/licenses/>.
;
; <fold definitions>
; <fold support of numbered names of x86-64 registers>
r0 equ rax
r1 equ rcx
r2 equ rdx
r6 equ rsi
r7 equ rdi
r0d equ eax
r1d equ ecx
r2d equ edx
r6d equ esi
r7d equ edi
r0w equ ax
r1w equ cx
r2w equ dx
r6w equ si
r7w equ di
r0b equ al
r1b equ cl
r2b equ dl
r6b equ sil
r7b equ dil
r0l equ al
r1l equ cl
r2l equ dl
r6l equ sil
r7l equ dil
; </fold>
; <fold language constants>
null = 0
true = 1
false = 0
; </fold>
; <fold stack tags>
TAG_EMPTY = $00
TAG_INT = $01
TAG_INT2 = $12
TAG_INT4 = $14
TAG_INT8 = $1918
TAG_LONG = $02
TAG_LONG2 = $22
TAG_LONG4 = $2524
TAG_LONG8 = $2b2a2928
TAG_FLOAT = $0f
TAG_FLOAT2 = $f2
TAG_FLOAT4 = $f4
TAG_FLOAT8 = $f9f8
TAG_DOUBLE = $0d
TAG_DOUBLE2 = $d2
TAG_DOUBLE4 = $d5d4
TAG_DOUBLE8 = $dbdad9d8
TAG_BYTE2 = $b2
TAG_BYTE4 = $b4
TAG_BYTE8 = $b8
TAG_SHORT2 = $52
TAG_SHORT4 = $54
TAG_SHORT8 = $58
TAG_REAL = $07
TAG_SUPPRESS = $99
TAG_OBJECT = $88
TAG_FLEAVE = $ef
TAG_MLEAVE = $cfca
TAG_ILEAVE = $afaeacaa
; </fold>
; <fold stack context field offsets>
; Тагированный стак вызовов имеет четыре области:
; 1. Область данных. Является массивом из 16-байтных элементов данных. Некоторые векторные типы (их всего 6: int8, long4, long8, float8, double4, double8) занимают 2 или 4 таких элемента.
; 2. Охранная область. Занимает определённое количество 16-байтных элементов на вершине (в начале) области данных, но не более 256 (4 КБ). При попытке записи данных в эту область возбуждается ошибка StackOverflowError.
; 3. Область тагов. Следует за областью данных и является массивом из 1-байтных тагов. Количество тагов равно количеству элементов данных, поэтому размер области тагов составляет 1/16 от размера области данных.
; Каждому элементу данных соответствует свой таг, определяющий тип данных этого элемента.
; 4. Область контекста. Следует за областью тагов и является дополнением к регистрам процессора. На эту область всегда ссылается регистр rbx в 64-битных программах, или ebx — в 32-битных.
; Эта область имеет размер 4 КБ и состоит из 64-битных полей:
context$zero = $0000 ; always 0 ; всегда равно нулю
context$guardEnd = $0008 ; stack guard block end pointer ; указатель на конец охранной области
context$dataPointer = $0010 ; stack data begin pointer (stack guard block begin pointer) ; указатель на начало области данных, он же – указатель на начало охранной области
context$dataLength = $0018 ; stack data size, in bytes ; размер области данных
context$tagsPointer = $0020 ; stack tags begin pointer (stack data end pointer) ; указатель на начало области тагов, он же — указатель на конец области данных
context$ehp = $0028 ; exception handler pointer ; указатель на обработчик исключений
context$tsp = $0030 ; tags stack pointer ; tsp — дополнение к rsp/esp, но ссылается на таг, а не на элемент данных
context$tbp = $0038 ; tags block pointer ; tbp — дополнение к rbp/ebp, но ссылается на таг, а не на элемент данных
context$irp = $0040 ; instruction return pointer ; указатель для возврата управления из процедуры-инструкции
context$srp = $0048 ; subject return pointer ; указатель для возврата управления из процедуры-субъекта
context$temp0 = $0050 ; instruction temporary data ; временные данные процедур-инструкций
context$temp1 = $0058 ; instruction temporary data ; временные данные процедур-инструкций
context$temp2 = $0060 ; instruction temporary data ; временные данные процедур-инструкций
context$temp3 = $0068 ; instruction temporary data ; временные данные процедур-инструкций
context$suppressedInstancePointer = $0070 ; suppressed exception instance pointer ; указатель на инстанцию подавленного исключения
context$suppressedInstructionPointer = $0078 ; suppressed exception instruction pointer ; указатель на инструкцию, возбудившую подавленное исключение
; Остальное место зарезервировано и может быть использовано для хранения значений регистров процессора в функциях обратного вызова (каллбаках, от слова callback).
; </fold>
; </fold>
; <fold common macroinstructions>
; <fold code>
macro proc procedureFullName* {
calign $04
procedureFullName:
}
macro end_proc { }
macro subj subjectFullName* {
calign $04
subj$#subjectFullName:
pop qword[rbx+context$srp]
}
macro end_subj {
jmp qword[rbx+context$srp]
}
macro inst [instructionFullName] {
common
calign $04
forward
inst$#instructionFullName:
common
pop qword[rbx+context$irp]
}
macro end_inst {
jmp qword[rbx+context$irp]
}
macro method methodFullName*, [argumentName, argumentType] {
common
calign $04
methodFullName:
local .argsize
local .tagsize
.argsize = $00
.tagsize = $00
reverse
if(~(argumentName eq) & ~(argumentType eq))
label .#argumentName at rbp+.argsize+$20
label .#argumentName#.tag at rdi+.tagsize+$02
if(argumentType in <long8, double8>)
.argsize = .argsize+$40
.tagsize = .tagsize+$04
else if(argumentType in <int8, long4, float8, double4>)
.argsize = .argsize+$20
.tagsize = .tagsize+$02
else
.argsize = .argsize+$10
.tagsize = .tagsize+$01
end if
end if
common
.size.arg = .argsize
.size.loc = $00
.tag.arg = .tagsize
.tag.loc = $00
}
macro loc localvarName*, localvarType* {
if(localvarType in <long8, double8>)
.size.loc = .size.loc+$40
.tag.loc = .tag.loc+$04
else if(localvarType in <int8, long4, float8, double4>)
.size.loc = .size.loc+$20
.tag.loc = .tag.loc+$02
else
.size.loc = .size.loc+$10
.tag.loc = .tag.loc+$01
end if
label .#localvarName at rbp-.size.loc
label .#localvarName#.tag at rdi-.tag.loc
}
macro impl classFullName*, serviceFullName* {
calign $04
classFullName#$$impl$$#serviceFullName:
}
; </fold>
; <fold debug info>
macro dbinfob compilerNameAndVersion* {
; базовая отладочная информация: только данные для построения трассировки стака
@@: db "DBB", $00
dd -@B+@F
db compilerNameAndVersion, $00
dalign $08
@@: dd debuginfo$string-@B
dd debuginfo$string.end-debuginfo$string
dd debuginfo$source-@B
dd debuginfo$source.end-debuginfo$source
dd debuginfo$entry-@B
dd debuginfo$entry.end-debuginfo$entry
}
; macro dbinfof compilerNameAndVersion* {
; ; полная отладочная информация: данные для построения трассировки стака + данные обо всех элементах программы
; ; на данный момент не реализована, поскольку нет отладчиков, которые могли бы её использовать
; @@: db "DBF", $00
; dd -@B+@F
; db compilerNameAndVersion, $00
; dalign $08
; @@: dd debuginfo$string-@B
; dd debuginfo$string.end-debuginfo$string
; dd debuginfo$source-@B
; dd debuginfo$source.end-debuginfo$source
; dd debuginfo$entry-@B
; dd debuginfo$entry.end-debuginfo$entry
; dd debuginfo$package-@B
; dd debuginfo$package.end-debuginfo$package
; dd debuginfo$class-@B
; dd debuginfo$class.end-debuginfo$class
; dd debuginfo$const-@B
; dd debuginfo$const.end-debuginfo$const
; dd debuginfo$globro-@B
; dd debuginfo$globro.end-debuginfo$globro
; dd debuginfo$globrw-@B
; dd debuginfo$globrw.end-debuginfo$globrw
; dd debuginfo$field-@B
; dd debuginfo$field.end-debuginfo$field
; dd debuginfo$property-@B
; dd debuginfo$property.end-debuginfo$property
; dd debuginfo$method-@B
; dd debuginfo$method.end-debuginfo$method
; dd debuginfo$loc-@B
; dd debuginfo$loc.end-debuginfo$loc
; }
macro dstr name* {
if(used .#name)
.#name:
db `name, $00
end if
}
macro dstrs name* {
if(used .$#name#$)
.$#name#$:
db '<', `name, '>', $00
end if
}
macro dsrc sourceName*, [nameChar] {
common
if(used .#sourceName)
.#sourceName:
end if
forward
if(used .#sourceName & ~(nameChar eq))
dw nameChar
end if
common
if(used .#sourceName)
dw $0000
end if
}
macro dent blockBegin*, blockEnd*, sourceName*, lineNumber*, className*, methodName* {
if(blockEnd > blockBegin)
@@: dd -@B+blockBegin
dd blockEnd-blockBegin
dd -@B+debuginfo$source.#sourceName
dd lineNumber
dd -@B+className
dd -@B+debuginfo$string.#methodName
dd $00000000 ; зарезервировано
dd $00000000 ; зарезервировано
end if
}
macro dents blockBegin*, blockEnd*, sourceName*, lineNumber*, className*, methodName* {
if(blockEnd > blockBegin)
@@: dd -@B+blockBegin
dd blockEnd-blockBegin
dd -@B+debuginfo$source.#sourceName
dd lineNumber
dd -@B+className
dd -@B+debuginfo$string.$#methodName#$
dd $00000000 ; зарезервировано
dd $00000000 ; зарезервировано
end if
}
; </fold>
; <fold resources>
macro avtresource resourceName*, fileName* {
local nameBegin
local nameEnd
local resBegin
local resEnd
dalign $10
dw nameEnd-nameBegin
nameBegin:
db resourceName
nameEnd:
dalign $04
dd resEnd-resBegin
resBegin:
file fileName
resEnd:
}
macro endresource {
dalign $10
dw $0000
}
; </fold>
; <fold data>
macro package packageFullName* {
dalign $10
packageFullName:
.package:
dq $0000000000000000, $0000000000000000, avt.lang.Package-.package, $0000000000000000
}
macro class classFullName* {
dalign $10
classFullName:
.class: dq $0000000000000000, $0000000000000000, avt.lang.Class-.class, $0000000000000000
}
macro glob globalvarFullName* {
dalign $10
globalvarFullName:
}
macro field offset*, fieldFullName* {
fieldFullName = offset
}
; </fold>
; <fold auxiliary>
macro calign a* {
nopvar (-$) and (a-1)
}
macro dalign a* {
repeat((-$) and (a-1))
db $00
end repeat
}
macro nopvar length* {
local .rem
.rem = length
while(.rem > 0)
if(.rem = 1)
db $90
break
else if(.rem = 2)
db $66, $90
break
else if(.rem = 3)
db $0f, $1f, $00
break
else if(.rem = 4)
db $0f, $1f, $40, $00
break
else if(.rem = 5)
db $0f, $1f, $44, $00, $00
break
else if(.rem = 6)
db $66, $0f, $1f, $44, $00, $00
break
else if(.rem = 7)
db $0f, $1f, $80, $00, $00, $00, $00
break
else if(.rem = 8)
db $0f, $1f, $84, $00, $00, $00, $00, $00
break
else
db $66, $0f, $1f, $84, $00, $00, $00, $00, $00
.rem = .rem-9
end if
end while
}
; </fold>
; </fold>
; <fold high-level instructions>
; <fold normal method>
macro menter {
lea rcx, [.L.EHP]
call inst$methodenter
if(.size.loc > 0)
mov ecx, .size.loc
call inst$stackrealize
end if
}
macro mreturn {
if(.size.arg > 0)
ret .size.arg
else
ret
end if
calign $04
.L.EHP:
}
macro mleave {
lea rcx, [rbp+.size.arg+$20]
call inst$methodleave
mreturn
}
macro mleaved {
lea rcx, [rbp+.size.arg+$20]
call inst$methodleaved
mreturn
}
macro mleaveq {
lea rcx, [rbp+.size.arg+$20]
call inst$methodleaveq
mreturn
}
macro mleavet {
lea rcx, [rbp+.size.arg+$20]
call inst$methodleavet
mreturn
}
macro mleavex {
lea rcx, [rbp+.size.arg+$20]
call inst$methodleavex
mreturn
}
macro mleavey {
lea rcx, [rbp+.size.arg+$20]
call inst$methodleavey
mreturn
}
macro mleavez {
lea rcx, [rbp+.size.arg+$20]
call inst$methodleavez
mreturn
}
macro mleaver {
lea rcx, [rbp+.size.arg+$20]
call inst$methodleaver
mreturn
}
macro mempty {
.D.END:
}
; </fold>
; <fold interrupt method>
macro ienter {
; должно быть реализовано в будущем
}
macro ileave {
; должно быть реализовано в будущем
iretq
calign $04
.L.EHP:
}
; </fold>
; <fold finally block>
macro fenter {
call inst$finallyenter
}
macro fleave {
call inst$finallyleave
ret
}
; </fold>
; <fold static block>
macro statictrylock classFullName* {
.class = classFullName
rloadclass .class
invokespeciald avt.lang.Class$clinitTryLock$
}
macro staticunlock {
rloadclass .class
invokespecial avt.lang.Class$clinitUnlock$
}
; </fold>
; <fold i*switch>
macro ilookupswitch defaultLabel*, [caseValue, caseLabel] {
common
call inst$ipop
forward
if(~(caseValue eq) & ~(caseLabel eq))
cmp eax, caseValue
je caseLabel
end if
common
jmp defaultLabel
}
macro itableswitch defaultLabel*, caseValue*, [caseLabel] {
common
local .L.000
local .count
.count = 0
forward
if(~(caseLabel eq))
.count = .count + 1
end if
common
call inst$ipop
sub eax, caseValue
jl defaultLabel
cmp eax, .count
jge defaultLabel
lea rcx, [.L.000]
movsxd rdx, [rcx+rax*4]
lea rcx, [rcx+rdx*1]
jmp rcx
calign $04
.L.000:
forward
if(~(caseLabel eq))
dd caseLabel-.L.000
end if
common
dq $cccccccccccccccc, $cccccccccccccccc
}
; </fold>
; <fold *load*>
macro bloadf {
bload false
}
macro bloadt {
bload true
}
macro rloadnull {
call inst$rpushnull
}
macro rloadclass classFullName* {
lea rax, [classFullName]
call inst$rpush
}
macro rloadstring stringIndex* {
iload stringIndex
invokestaticr avt.lang.String$getConstant$int$
}
; </fold>
; <fold *load>
macro iload operand* {
mov eax, operand
call inst$ipush
}
macro i2load operand* {
vmovq xmm0, operand
call inst$i2push
}
macro i4load operand* {
vmovdqa xmm0, operand
call inst$i4push
}
macro i8load operand* {
vmovdqu ymm0, operand
call inst$i8push
}
macro lload operand* {
mov rax, operand
call inst$lpush
}
macro l2load operand* {
vmovdqa xmm0, operand
call inst$l2push
}
macro l4load operand* {
vmovdqu ymm0, operand
call inst$l4push
}
macro l8load operand* {
vmovdqu64 zmm0, operand
call inst$l8push
}
macro fload operand* {
vmovd xmm0, operand
call inst$fpush
}
macro f2load operand* {
vmovq xmm0, operand
call inst$f2push
}
macro f4load operand* {
vmovdqa xmm0, operand
call inst$f4push
}
macro f8load operand* {
vmovdqu ymm0, operand
call inst$f8push
}
macro dload operand* {
vmovq xmm0, operand
call inst$dpush
}
macro d2load operand* {
vmovdqa xmm0, operand
call inst$d2push
}
macro d4load operand* {
vmovdqu ymm0, operand
call inst$d4push
}
macro d8load operand* {
vmovdqu64 zmm0, operand
call inst$d8push
}
macro bload operand* {
if(operand eqtype 0)
mov al, operand
movsx eax, al
else
movsx eax, byte operand
end if
call inst$ipush
}
macro b2load operand* {
movzx eax, word operand
vmovd xmm0, eax
call inst$b2push
}
macro b4load operand* {
vmovd xmm0, operand
call inst$b4push
}
macro b8load operand* {
vmovq xmm0, operand
call inst$b8push
}
macro sload operand* {
if(operand eqtype 0)
mov ax, operand
movsx eax, ax
else
movsx eax, word operand
end if
call inst$ipush
}
macro s2load operand* {
vmovd xmm0, operand
call inst$s2push
}
macro s4load operand* {
vmovq xmm0, operand
call inst$s4push
}
macro s8load operand* {
vmovdqa xmm0, operand
call inst$s8push
}
macro xload operand* {
fld tbyte operand
call inst$xpush
}
macro cload operand* {
if(operand eqtype 0)
mov ax, operand
movzx eax, ax
else
movzx eax, word operand
end if
call inst$ipush
}
macro rload operand* {
mov rax, operand
call inst$rpush
}
; </fold>
; <fold *store>
macro istore operand* {
call inst$ipop
mov dword operand, eax
}
macro i2store operand* {
call inst$i2pop
vmovq qword operand, xmm0
}
macro i4store operand* {
call inst$i4pop
vmovdqa xword operand, xmm0
}
macro i8store operand* {
call inst$i8pop
vmovdqu yword operand, ymm0
}
macro lstore operand* {
call inst$lpop
mov qword operand, rax
}
macro l2store operand* {
call inst$l2pop
vmovdqa xword operand, xmm0
}
macro l4store operand* {
call inst$l4pop
vmovdqu yword operand, ymm0
}
macro l8store operand* {
call inst$l8pop
vmovdqu64 zword operand, zmm0
}
macro fstore operand* {
call inst$fpop
vmovd dword operand, xmm0
}
macro f2store operand* {
call inst$f2pop
vmovq qword operand, xmm0
}
macro f4store operand* {
call inst$f4pop
vmovdqa xword operand, xmm0
}
macro f8store operand* {
call inst$f8pop
vmovdqu yword operand, ymm0
}
macro dstore operand* {
call inst$dpop
vmovq qword operand, xmm0
}
macro d2store operand* {
call inst$d2pop
vmovdqa xword operand, xmm0
}
macro d4store operand* {
call inst$d4pop
vmovdqu yword operand, ymm0
}
macro d8store operand* {
call inst$d8pop
vmovdqu64 zword operand, zmm0
}
macro bstore operand* {
call inst$ipop
mov byte operand, al
}
macro b2store operand* {
call inst$b2pop
mov word operand, ax
}
macro b4store operand* {
call inst$b4pop
vmovd dword operand, xmm0
}
macro b8store operand* {
call inst$b8pop
vmovq qword operand, xmm0
}
macro sstore operand* {
call inst$ipop
mov word operand, ax
}
macro s2store operand* {
call inst$s2pop
vmovd dword operand, xmm0
}
macro s4store operand* {
call inst$s4pop
vmovq qword operand, xmm0
}
macro s8store operand* {
call inst$s8pop
vmovdqa xword operand, xmm0
}
macro xstore operand* {
call inst$xpop
fstp tbyte operand
}
macro cstore operand* {
call inst$ipop
mov word operand, ax
}
macro rstore operand* {
local .L.000
call inst$rpop
xchg qword operand, rax
test rax, rax
jz .L.000
lock dec qword[rax+avt.lang.Object$fldRefCountFromOthers]
.L.000:
}
; </fold>
; <fold *loadloc>
macro lverify loc*, tag* {
local .L.000
rdtbp
if(tag in <TAG_LONG8, TAG_DOUBLE8>)
cmp dword[.#loc#.tag], tag
else if(tag in <TAG_INT8, TAG_LONG4, TAG_FLOAT8, TAG_DOUBLE4>)
cmp word[.#loc#.tag], tag
else
cmp byte[.#loc#.tag], tag
end if
je .L.000
call inst$throwVerifyError
.L.000:
}
macro iloadloc loc* {
lverify loc, TAG_INT
iload [.#loc]
}
macro i2loadloc loc* {
lverify loc, TAG_INT2
i2load [.#loc]
}
macro i4loadloc loc* {
lverify loc, TAG_INT4
i4load [.#loc]
}
macro i8loadloc loc* {
lverify loc, TAG_INT8
i8load [.#loc]
}
macro lloadloc loc* {
lverify loc, TAG_LONG
lload [.#loc]
}
macro l2loadloc loc* {
lverify loc, TAG_LONG2
l2load [.#loc]
}
macro l4loadloc loc* {
lverify loc, TAG_LONG4
l4load [.#loc]
}
macro l8loadloc loc* {
lverify loc, TAG_LONG8
l8load [.#loc]
}
macro floadloc loc* {
lverify loc, TAG_FLOAT
fload [.#loc]
}
macro f2loadloc loc* {
lverify loc, TAG_FLOAT2
f2load [.#loc]
}
macro f4loadloc loc* {
lverify loc, TAG_FLOAT4
f4load [.#loc]
}
macro f8loadloc loc* {
lverify loc, TAG_FLOAT8
f8load [.#loc]
}
macro dloadloc loc* {
lverify loc, TAG_DOUBLE
dload [.#loc]
}
macro d2loadloc loc* {
lverify loc, TAG_DOUBLE2
d2load [.#loc]
}
macro d4loadloc loc* {
lverify loc, TAG_DOUBLE4
d4load [.#loc]
}
macro d8loadloc loc* {
lverify loc, TAG_DOUBLE8
d8load [.#loc]
}
macro b2loadloc loc* {
lverify loc, TAG_BYTE2
b2load [.#loc]
}
macro b4loadloc loc* {
lverify loc, TAG_BYTE4
b4load [.#loc]
}
macro b8loadloc loc* {
lverify loc, TAG_BYTE8
b8load [.#loc]
}
macro s2loadloc loc* {
lverify loc, TAG_SHORT2
s2load [.#loc]
}
macro s4loadloc loc* {
lverify loc, TAG_SHORT4
s4load [.#loc]
}
macro s8loadloc loc* {
lverify loc, TAG_SHORT8
s8load [.#loc]
}
macro xloadloc loc* {
lverify loc, TAG_REAL
xload [.#loc]
}
macro rloadloc loc* {
lverify loc, TAG_OBJECT
rload [.#loc]
}
; </fold>
; <fold *storeloc>
macro lrelease loc* {
local .L.000
rdtbp
cmp byte[.#loc#.tag], TAG_OBJECT
jne .L.000
mov rdx, [.#loc]
test rdx, rdx
jz .L.000
lock dec qword[rdx+avt.lang.Object$fldRefCountFromOthers]
.L.000:
}
macro istoreloc loc* {
call inst$ipop
lrelease loc
mov qword[.#loc+$08], $00
mov qword[.#loc+$00], rax
mov byte[.#loc#.tag], TAG_INT
}
macro i2storeloc loc* {
call inst$i2pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_INT2
}
macro i4storeloc loc* {
call inst$i4pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_INT4
}
macro i8storeloc loc* {
call inst$i8pop
lrelease loc
vmovdqu yword[.#loc+$00], ymm0
mov word[.#loc#.tag], TAG_INT8
}
macro lstoreloc loc* {
call inst$lpop
lrelease loc
mov qword[.#loc+$08], $00
mov qword[.#loc+$00], rax
mov byte[.#loc#.tag], TAG_LONG
}
macro l2storeloc loc* {
call inst$l2pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_LONG2
}
macro l4storeloc loc* {
call inst$l4pop
lrelease loc
vmovdqu yword[.#loc+$00], ymm0
mov word[.#loc#.tag], TAG_LONG4
}
macro l8storeloc loc* {
call inst$l8pop
lrelease loc
vmovdqu64 zword[.#loc+$00], zmm0
mov dword[.#loc#.tag], TAG_LONG8
}
macro fstoreloc loc* {
call inst$fpop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_FLOAT
}
macro f2storeloc loc* {
call inst$f2pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_FLOAT2
}
macro f4storeloc loc* {
call inst$f4pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_FLOAT4
}
macro f8storeloc loc* {
call inst$f8pop
lrelease loc
vmovdqu yword[.#loc+$00], ymm0
mov word[.#loc#.tag], TAG_FLOAT8
}
macro dstoreloc loc* {
call inst$dpop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_DOUBLE
}
macro d2storeloc loc* {
call inst$d2pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_DOUBLE2
}
macro d4storeloc loc* {
call inst$d4pop
lrelease loc
vmovdqu yword[.#loc+$00], ymm0
mov word[.#loc#.tag], TAG_DOUBLE4
}
macro d8storeloc loc* {
call inst$d8pop
lrelease loc
vmovdqu64 zword[.#loc+$00], zmm0
mov dword[.#loc#.tag], TAG_DOUBLE8
}
macro b2storeloc loc* {
call inst$b2pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_BYTE2
}
macro b4storeloc loc* {
call inst$b4pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_BYTE4
}
macro b8storeloc loc* {
call inst$b8pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_BYTE8
}
macro s2storeloc loc* {
call inst$s2pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_SHORT2
}
macro s4storeloc loc* {
call inst$s4pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_SHORT4
}
macro s8storeloc loc* {
call inst$s8pop
lrelease loc
vmovdqa xword[.#loc+$00], xmm0
mov byte[.#loc#.tag], TAG_SHORT8
}
macro xstoreloc loc* {
call inst$xpop
lrelease loc
mov qword[.#loc+$08], $00
fstp tbyte[.#loc+$00]
mov byte[.#loc#.tag], TAG_REAL
}
macro rstoreloc loc* {
call inst$rpop
lrelease loc
mov qword[.#loc+$08], $00
mov qword[.#loc+$00], rax
mov byte[.#loc#.tag], TAG_OBJECT
}
; </fold>
; <fold *inc>
macro iinc loc* {
lverify loc, TAG_INT
inc dword[.#loc]
}
macro i2inc loc* {
lverify loc, TAG_INT2
inc dword[.#loc]
}
macro i4inc loc* {
lverify loc, TAG_INT4
inc dword[.#loc]
}
macro i8inc loc* {
lverify loc, TAG_INT8
inc dword[.#loc]
}
macro linc loc* {
lverify loc, TAG_LONG
inc qword[.#loc]
}
macro l2inc loc* {
lverify loc, TAG_LONG2
inc qword[.#loc]
}
macro l4inc loc* {
lverify loc, TAG_LONG4
inc qword[.#loc]
}
macro l8inc loc* {
lverify loc, TAG_LONG8
inc qword[.#loc]
}
macro finc loc* {
lverify loc, TAG_FLOAT
vmovd xmm0, [.#loc]
vaddss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f2inc loc* {
lverify loc, TAG_FLOAT2
vmovd xmm0, [.#loc]
vaddss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f4inc loc* {
lverify loc, TAG_FLOAT4
vmovd xmm0, [.#loc]
vaddss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f8inc loc* {
lverify loc, TAG_FLOAT8
vmovd xmm0, [.#loc]
vaddss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro dinc loc* {
lverify loc, TAG_DOUBLE
vmovq xmm0, [.#loc]
vaddsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d2inc loc* {
lverify loc, TAG_DOUBLE2
vmovq xmm0, [.#loc]
vaddsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d4inc loc* {
lverify loc, TAG_DOUBLE4
vmovq xmm0, [.#loc]
vaddsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d8inc loc* {
lverify loc, TAG_DOUBLE8
vmovq xmm0, [.#loc]
vaddsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro binc loc* {
lverify loc, TAG_INT
mov al, [.#loc]
inc al
movsx eax, al
mov dword[.#loc], eax
}
macro b2inc loc* {
lverify loc, TAG_BYTE2
inc byte[.#loc]
}
macro b4inc loc* {
lverify loc, TAG_BYTE4
inc byte[.#loc]
}
macro b8inc loc* {
lverify loc, TAG_BYTE8
inc byte[.#loc]
}
macro sinc loc* {
lverify loc, TAG_INT
mov ax, [.#loc]
inc ax
movsx eax, ax
mov dword[.#loc], eax
}
macro s2inc loc* {
lverify loc, TAG_SHORT2
inc word[.#loc]
}
macro s4inc loc* {
lverify loc, TAG_SHORT4
inc word[.#loc]
}
macro s8inc loc* {
lverify loc, TAG_SHORT8
inc word[.#loc]
}
macro xinc loc* {
lverify loc, TAG_REAL
fld tbyte[.#loc]
fiadd dword[i8.id]
fstp tbyte[.#loc]
}
macro cinc loc* {
lverify loc, TAG_INT
mov ax, [.#loc]
inc ax
movzx eax, ax
mov dword[.#loc], eax
}
; </fold>
; <fold *dec>
macro idec loc* {
lverify loc, TAG_INT
dec dword[.#loc]
}
macro i2dec loc* {
lverify loc, TAG_INT2
dec dword[.#loc]
}
macro i4dec loc* {
lverify loc, TAG_INT4
dec dword[.#loc]
}
macro i8dec loc* {
lverify loc, TAG_INT8
dec dword[.#loc]
}
macro ldec loc* {
lverify loc, TAG_LONG
dec qword[.#loc]
}
macro l2dec loc* {
lverify loc, TAG_LONG2
dec qword[.#loc]
}
macro l4dec loc* {
lverify loc, TAG_LONG4
dec qword[.#loc]
}
macro l8dec loc* {
lverify loc, TAG_LONG8
dec qword[.#loc]
}
macro fdec loc* {
lverify loc, TAG_FLOAT
vmovd xmm0, [.#loc]
vsubss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f2dec loc* {
lverify loc, TAG_FLOAT2
vmovd xmm0, [.#loc]
vsubss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f4dec loc* {
lverify loc, TAG_FLOAT4
vmovd xmm0, [.#loc]
vsubss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f8dec loc* {
lverify loc, TAG_FLOAT8
vmovd xmm0, [.#loc]
vsubss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro ddec loc* {
lverify loc, TAG_DOUBLE
vmovq xmm0, [.#loc]
vsubsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d2dec loc* {
lverify loc, TAG_DOUBLE2
vmovq xmm0, [.#loc]
vsubsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d4dec loc* {
lverify loc, TAG_DOUBLE4
vmovq xmm0, [.#loc]
vsubsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d8dec loc* {
lverify loc, TAG_DOUBLE8
vmovq xmm0, [.#loc]
vsubsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro bdec loc* {
lverify loc, TAG_INT
mov al, [.#loc]
dec al
movsx eax, al
mov dword[.#loc], eax
}
macro b2dec loc* {
lverify loc, TAG_BYTE2
dec byte[.#loc]
}
macro b4dec loc* {
lverify loc, TAG_BYTE4
dec byte[.#loc]
}
macro b8dec loc* {
lverify loc, TAG_BYTE8
dec byte[.#loc]
}
macro sdec loc* {
lverify loc, TAG_INT
mov ax, [.#loc]
dec ax
movsx eax, ax
mov dword[.#loc], eax
}
macro s2dec loc* {
lverify loc, TAG_SHORT2
dec word[.#loc]
}
macro s4dec loc* {
lverify loc, TAG_SHORT4
dec word[.#loc]
}
macro s8dec loc* {
lverify loc, TAG_SHORT8
dec word[.#loc]
}
macro xdec loc* {
lverify loc, TAG_REAL
fld tbyte[.#loc]
fisub dword[i8.id]
fstp tbyte[.#loc]
}
macro cdec loc* {
lverify loc, TAG_INT
mov ax, [.#loc]
dec ax
movzx eax, ax
mov dword[.#loc], eax
}
; </fold>
; <fold *incpost>
macro iincpost loc* {
iloadloc loc
inc dword[.#loc]
}
macro i2incpost loc* {
i2loadloc loc
inc dword[.#loc]
}
macro i4incpost loc* {
i4loadloc loc
inc dword[.#loc]
}
macro i8incpost loc* {
i8loadloc loc
inc dword[.#loc]
}
macro lincpost loc* {
lloadloc loc
inc qword[.#loc]
}
macro l2incpost loc* {
l2loadloc loc
inc qword[.#loc]
}
macro l4incpost loc* {
l4loadloc loc
inc qword[.#loc]
}
macro l8incpost loc* {
l8loadloc loc
inc qword[.#loc]
}
macro fincpost loc* {
floadloc loc
vaddss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f2incpost loc* {
f2loadloc loc
vaddss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f4incpost loc* {
f4loadloc loc
vaddss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f8incpost loc* {
f8loadloc loc
vaddss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro dincpost loc* {
dloadloc loc
vaddsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d2incpost loc* {
d2loadloc loc
vaddsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d4incpost loc* {
d4loadloc loc
vaddsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d8incpost loc* {
d8loadloc loc
vaddsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro bincpost loc* {
iloadloc loc
inc al
movsx eax, al
mov dword[.#loc], eax
}
macro b2incpost loc* {
b2loadloc loc
inc byte[.#loc]
}
macro b4incpost loc* {
b4loadloc loc
inc byte[.#loc]
}
macro b8incpost loc* {
b8loadloc loc
inc byte[.#loc]
}
macro sincpost loc* {
iloadloc loc
inc ax
movsx eax, ax
mov dword[.#loc], eax
}
macro s2incpost loc* {
s2loadloc loc
inc word[.#loc]
}
macro s4incpost loc* {
s4loadloc loc
inc word[.#loc]
}
macro s8incpost loc* {
s8loadloc loc
inc word[.#loc]
}
macro xincpost loc* {
lverify loc, TAG_REAL
fld tbyte[.#loc]
fld st0
call inst$xpush
fiadd dword[i8.id]
fstp tbyte[.#loc]
}
macro cincpost loc* {
iloadloc loc
inc ax
movzx eax, ax
mov dword[.#loc], eax
}
; </fold>
; <fold *decpost>
macro idecpost loc* {
iloadloc loc
dec dword[.#loc]
}
macro i2decpost loc* {
i2loadloc loc
dec dword[.#loc]
}
macro i4decpost loc* {
i4loadloc loc
dec dword[.#loc]
}
macro i8decpost loc* {
i8loadloc loc
dec dword[.#loc]
}
macro ldecpost loc* {
lloadloc loc
dec qword[.#loc]
}
macro l2decpost loc* {
l2loadloc loc
dec qword[.#loc]
}
macro l4decpost loc* {
l4loadloc loc
dec qword[.#loc]
}
macro l8decpost loc* {
l8loadloc loc
dec qword[.#loc]
}
macro fdecpost loc* {
floadloc loc
vsubss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f2decpost loc* {
f2loadloc loc
vsubss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f4decpost loc* {
f4loadloc loc
vsubss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro f8decpost loc* {
f8loadloc loc
vsubss xmm0, xmm0, [f8.id]
vmovd dword[.#loc], xmm0
}
macro ddecpost loc* {
dloadloc loc
vsubsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d2decpost loc* {
d2loadloc loc
vsubsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d4decpost loc* {
d4loadloc loc
vsubsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro d8decpost loc* {
d8loadloc loc
vsubsd xmm0, xmm0, [d8.id]
vmovq qword[.#loc], xmm0
}
macro bdecpost loc* {
iloadloc loc
dec al
movsx eax, al
mov dword[.#loc], eax
}
macro b2decpost loc* {
b2loadloc loc
dec byte[.#loc]
}
macro b4decpost loc* {
b4loadloc loc
dec byte[.#loc]
}
macro b8decpost loc* {
b8loadloc loc
dec byte[.#loc]
}
macro sdecpost loc* {
iloadloc loc
dec ax
movsx eax, ax
mov dword[.#loc], eax
}
macro s2decpost loc* {
s2loadloc loc
dec word[.#loc]
}
macro s4decpost loc* {
s4loadloc loc
dec word[.#loc]
}
macro s8decpost loc* {
s8loadloc loc
dec word[.#loc]
}
macro xdecpost loc* {
lverify loc, TAG_REAL
fld tbyte[.#loc]
fld st0
call inst$xpush
fisub dword[i8.id]
fstp tbyte[.#loc]
}
macro cdecpost loc* {
iloadloc loc
dec ax
movzx eax, ax
mov dword[.#loc], eax
}
; </fold>
; <fold *incpred>
macro iincpred loc* {
lverify loc, TAG_INT
mov ecx, $10
call inst$stackrealize
inc dword[.#loc]
mov eax, [.#loc]
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_INT
}
macro i2incpred loc* {
lverify loc, TAG_INT2
mov ecx, $10
call inst$stackrealize
inc dword[.#loc]
vmovq xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_INT2
}
macro i4incpred loc* {
lverify loc, TAG_INT4
mov ecx, $10
call inst$stackrealize
inc dword[.#loc]
vmovdqa xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_INT4
}
macro i8incpred loc* {
lverify loc, TAG_INT8
mov ecx, $20
call inst$stackrealize
inc dword[.#loc]
vmovdqu ymm0, [.#loc]
vmovdqu yword[rsp], ymm0
set TAG_INT8
}
macro lincpred loc* {
lverify loc, TAG_LONG
mov ecx, $10
call inst$stackrealize
inc qword[.#loc]
mov rax, [.#loc]
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_LONG
}
macro l2incpred loc* {
lverify loc, TAG_LONG2
mov ecx, $10
call inst$stackrealize
inc qword[.#loc]
vmovdqa xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_LONG2
}
macro l4incpred loc* {
lverify loc, TAG_LONG4
mov ecx, $20
call inst$stackrealize
inc qword[.#loc]
vmovdqu ymm0, [.#loc]
vmovdqu yword[rsp], ymm0
set TAG_LONG4
}
macro l8incpred loc* {
lverify loc, TAG_LONG8
mov ecx, $40
call inst$stackrealize
inc qword[.#loc]
vmovdqu64 zmm0, [.#loc]
vmovdqu64 zword[rsp], zmm0
set TAG_LONG8
}
macro fincpred loc* {
lverify loc, TAG_FLOAT
mov ecx, $10
call inst$stackrealize
vmovd xmm0, [.#loc]
vaddss xmm0, xmm0, [f8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_FLOAT
}
macro f2incpred loc* {
lverify loc, TAG_FLOAT2
mov ecx, $10
call inst$stackrealize
vmovq xmm0, [.#loc]
vaddps xmm0, xmm0, [f8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_FLOAT2
}
macro f4incpred loc* {
lverify loc, TAG_FLOAT4
mov ecx, $10
call inst$stackrealize
vmovdqa xmm0, [.#loc]
vaddps xmm0, xmm0, [f8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_FLOAT4
}
macro f8incpred loc* {
lverify loc, TAG_FLOAT8
mov ecx, $20
call inst$stackrealize
vmovdqu ymm0, [.#loc]
vaddps ymm0, ymm0, [f8.id]
vmovdqu yword[.#loc], ymm0
vmovdqu yword[rsp], ymm0
set TAG_FLOAT8
}
macro dincpred loc* {
lverify loc, TAG_DOUBLE
mov ecx, $10
call inst$stackrealize
vmovq xmm0, [.#loc]
vaddsd xmm0, xmm0, [d8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_DOUBLE
}
macro d2incpred loc* {
lverify loc, TAG_DOUBLE2
mov ecx, $10
call inst$stackrealize
vmovdqa xmm0, [.#loc]
vaddpd xmm0, xmm0, [d8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_DOUBLE2
}
macro d4incpred loc* {
lverify loc, TAG_DOUBLE4
mov ecx, $20
call inst$stackrealize
vmovdqu ymm0, [.#loc]
vaddpd ymm0, ymm0, [d8.id]
vmovdqu yword[.#loc], ymm0
vmovdqu yword[rsp], ymm0
set TAG_DOUBLE4
}
macro d8incpred loc* {
lverify loc, TAG_DOUBLE8
mov ecx, $40
call inst$stackrealize
vmovdqu64 zmm0, [.#loc]
vaddpd zmm0, zmm0, [d8.id]
vmovdqu64 zword[.#loc], zmm0
vmovdqu64 zword[rsp], zmm0
set TAG_DOUBLE8
}
macro bincpred loc* {
lverify loc, TAG_INT
mov ecx, $10
call inst$stackrealize
mov al, [.#loc]
inc al
movsx eax, al
mov dword[.#loc], eax
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_INT
}
macro b2incpred loc* {
lverify loc, TAG_BYTE2
mov ecx, $10
call inst$stackrealize
inc byte[.#loc]
movzx eax, word[.#loc]
vmovd xmm0, eax
vmovdqa xword[rsp], xmm0
set TAG_BYTE2
}
macro b4incpred loc* {
lverify loc, TAG_BYTE4
mov ecx, $10
call inst$stackrealize
inc byte[.#loc]
vmovd xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_BYTE4
}
macro b8incpred loc* {
lverify loc, TAG_BYTE8
mov ecx, $10
call inst$stackrealize
inc byte[.#loc]
vmovq xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_BYTE8
}
macro sincpred loc* {
lverify loc, TAG_INT
mov ecx, $10
call inst$stackrealize
mov ax, [.#loc]
inc ax
movsx eax, ax
mov dword[.#loc], eax
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_INT
}
macro s2incpred loc* {
lverify loc, TAG_SHORT2
mov ecx, $10
call inst$stackrealize
inc word[.#loc]
vmovd xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_SHORT2
}
macro s4incpred loc* {
lverify loc, TAG_SHORT4
mov ecx, $10
call inst$stackrealize
inc word[.#loc]
vmovq xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_SHORT4
}
macro s8incpred loc* {
lverify loc, TAG_SHORT8
mov ecx, $10
call inst$stackrealize
inc word[.#loc]
vmovdqa xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_SHORT8
}
macro xincpred loc* {
lverify loc, TAG_REAL
mov ecx, $10
call inst$stackrealize
mov qword[rsp+$08], $00
fld tbyte[.#loc]
fiadd dword[i8.id]
fld st0
fstp tbyte[.#loc]
fstp tbyte[rsp+$00]
set TAG_REAL
}
macro cincpred loc* {
lverify loc, TAG_INT
mov ecx, $10
call inst$stackrealize
mov ax, [.#loc]
inc ax
movzx eax, ax
mov dword[.#loc], eax
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_INT
}
; </fold>
; <fold *decpred>
macro idecpred loc* {
lverify loc, TAG_INT
mov ecx, $10
call inst$stackrealize
dec dword[.#loc]
mov eax, [.#loc]
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_INT
}
macro i2decpred loc* {
lverify loc, TAG_INT2
mov ecx, $10
call inst$stackrealize
dec dword[.#loc]
vmovq xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_INT2
}
macro i4decpred loc* {
lverify loc, TAG_INT4
mov ecx, $10
call inst$stackrealize
dec dword[.#loc]
vmovdqa xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_INT4
}
macro i8decpred loc* {
lverify loc, TAG_INT8
mov ecx, $20
call inst$stackrealize
dec dword[.#loc]
vmovdqu ymm0, [.#loc]
vmovdqu yword[rsp], ymm0
set TAG_INT8
}
macro ldecpred loc* {
lverify loc, TAG_LONG
mov ecx, $10
call inst$stackrealize
dec qword[.#loc]
mov rax, [.#loc]
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_LONG
}
macro l2decpred loc* {
lverify loc, TAG_LONG2
mov ecx, $10
call inst$stackrealize
dec qword[.#loc]
vmovdqa xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_LONG2
}
macro l4decpred loc* {
lverify loc, TAG_LONG4
mov ecx, $20
call inst$stackrealize
dec qword[.#loc]
vmovdqu ymm0, [.#loc]
vmovdqu yword[rsp], ymm0
set TAG_LONG4
}
macro l8decpred loc* {
lverify loc, TAG_LONG8
mov ecx, $40
call inst$stackrealize
dec qword[.#loc]
vmovdqu64 zmm0, [.#loc]
vmovdqu64 zword[rsp], zmm0
set TAG_LONG8
}
macro fdecpred loc* {
lverify loc, TAG_FLOAT
mov ecx, $10
call inst$stackrealize
vmovd xmm0, [.#loc]
vsubss xmm0, xmm0, [f8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_FLOAT
}
macro f2decpred loc* {
lverify loc, TAG_FLOAT2
mov ecx, $10
call inst$stackrealize
vmovq xmm0, [.#loc]
vsubps xmm0, xmm0, [f8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_FLOAT2
}
macro f4decpred loc* {
lverify loc, TAG_FLOAT4
mov ecx, $10
call inst$stackrealize
vmovdqa xmm0, [.#loc]
vsubps xmm0, xmm0, [f8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_FLOAT4
}
macro f8decpred loc* {
lverify loc, TAG_FLOAT8
mov ecx, $20
call inst$stackrealize
vmovdqu ymm0, [.#loc]
vsubps ymm0, ymm0, [f8.id]
vmovdqu yword[.#loc], ymm0
vmovdqu yword[rsp], ymm0
set TAG_FLOAT8
}
macro ddecpred loc* {
lverify loc, TAG_DOUBLE
mov ecx, $10
call inst$stackrealize
vmovq xmm0, [.#loc]
vsubsd xmm0, xmm0, [d8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_DOUBLE
}
macro d2decpred loc* {
lverify loc, TAG_DOUBLE2
mov ecx, $10
call inst$stackrealize
vmovdqa xmm0, [.#loc]
vsubpd xmm0, xmm0, [d8.id]
vmovdqa xword[.#loc], xmm0
vmovdqa xword[rsp], xmm0
set TAG_DOUBLE2
}
macro d4decpred loc* {
lverify loc, TAG_DOUBLE4
mov ecx, $20
call inst$stackrealize
vmovdqu ymm0, [.#loc]
vsubpd ymm0, ymm0, [d8.id]
vmovdqu yword[.#loc], ymm0
vmovdqu yword[rsp], ymm0
set TAG_DOUBLE4
}
macro d8decpred loc* {
lverify loc, TAG_DOUBLE8
mov ecx, $40
call inst$stackrealize
vmovdqu64 zmm0, [.#loc]
vsubpd zmm0, zmm0, [d8.id]
vmovdqu64 zword[.#loc], zmm0
vmovdqu64 zword[rsp], zmm0
set TAG_DOUBLE8
}
macro bdecpred loc* {
lverify loc, TAG_INT
mov ecx, $10
call inst$stackrealize
mov al, [.#loc]
dec al
movsx eax, al
mov dword[.#loc], eax
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_INT
}
macro b2decpred loc* {
lverify loc, TAG_BYTE2
mov ecx, $10
call inst$stackrealize
dec byte[.#loc]
movzx eax, word[.#loc]
vmovd xmm0, eax
vmovdqa xword[rsp], xmm0
set TAG_BYTE2
}
macro b4decpred loc* {
lverify loc, TAG_BYTE4
mov ecx, $10
call inst$stackrealize
dec byte[.#loc]
vmovd xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_BYTE4
}
macro b8decpred loc* {
lverify loc, TAG_BYTE8
mov ecx, $10
call inst$stackrealize
dec byte[.#loc]
vmovq xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_BYTE8
}
macro sdecpred loc* {
lverify loc, TAG_INT
mov ecx, $10
call inst$stackrealize
mov ax, [.#loc]
dec ax
movsx eax, ax
mov dword[.#loc], eax
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_INT
}
macro s2decpred loc* {
lverify loc, TAG_SHORT2
mov ecx, $10
call inst$stackrealize
dec word[.#loc]
vmovd xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_SHORT2
}
macro s4decpred loc* {
lverify loc, TAG_SHORT4
mov ecx, $10
call inst$stackrealize
dec word[.#loc]
vmovq xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_SHORT4
}
macro s8decpred loc* {
lverify loc, TAG_SHORT8
mov ecx, $10
call inst$stackrealize
dec word[.#loc]
vmovdqa xmm0, [.#loc]
vmovdqa xword[rsp], xmm0
set TAG_SHORT8
}
macro xdecpred loc* {
lverify loc, TAG_REAL
mov ecx, $10
call inst$stackrealize
mov qword[rsp+$08], $00
fld tbyte[.#loc]
fisub dword[i8.id]
fld st0
fstp tbyte[.#loc]
fstp tbyte[rsp+$00]
set TAG_REAL
}
macro cdecpred loc* {
lverify loc, TAG_INT
mov ecx, $10
call inst$stackrealize
mov ax, [.#loc]
dec ax
movzx eax, ax
mov dword[.#loc], eax
mov qword[rsp+$08], $00
mov qword[rsp+$00], rax
set TAG_INT
}
; </fold>
; <fold getfield*>
macro getfieldi offset* {
mov ecx, offset
call inst$getfieldi
}
macro getfieldi2 offset* {
mov ecx, offset
call inst$getfieldi2
}
macro getfieldi4 offset* {
mov ecx, offset
call inst$getfieldi4
}
macro getfieldi8 offset* {
mov ecx, offset
call inst$getfieldi8
}
macro getfieldl offset* {
mov ecx, offset
call inst$getfieldl
}
macro getfieldl2 offset* {
mov ecx, offset
call inst$getfieldl2
}
macro getfieldl4 offset* {
mov ecx, offset
call inst$getfieldl4
}
macro getfieldl8 offset* {
mov ecx, offset
call inst$getfieldl8
}
macro getfieldf offset* {
mov ecx, offset
call inst$getfieldf
}
macro getfieldf2 offset* {
mov ecx, offset
call inst$getfieldf2
}
macro getfieldf4 offset* {
mov ecx, offset
call inst$getfieldf4
}
macro getfieldf8 offset* {
mov ecx, offset
call inst$getfieldf8
}
macro getfieldd offset* {
mov ecx, offset
call inst$getfieldd
}
macro getfieldd2 offset* {
mov ecx, offset
call inst$getfieldd2
}
macro getfieldd4 offset* {
mov ecx, offset
call inst$getfieldd4
}
macro getfieldd8 offset* {
mov ecx, offset
call inst$getfieldd8
}
macro getfieldb offset* {
mov ecx, offset
call inst$getfieldb
}
macro getfieldb2 offset* {
mov ecx, offset
call inst$getfieldb2
}
macro getfieldb4 offset* {
mov ecx, offset
call inst$getfieldb4
}
macro getfieldb8 offset* {
mov ecx, offset
call inst$getfieldb8
}
macro getfields offset* {
mov ecx, offset
call inst$getfields
}
macro getfields2 offset* {
mov ecx, offset
call inst$getfields2
}
macro getfields4 offset* {
mov ecx, offset
call inst$getfields4
}
macro getfields8 offset* {
mov ecx, offset
call inst$getfields8
}
macro getfieldx offset* {
mov ecx, offset
call inst$getfieldx
}
macro getfieldc offset* {
mov ecx, offset
call inst$getfieldc
}
macro getfieldr offset* {
mov ecx, offset
call inst$getfieldr
}
; </fold>
; <fold getstructfield*>
macro getstructfieldi offset* {
mov ecx, offset
call inst$getstructfieldi
}
macro getstructfieldi2 offset* {
mov ecx, offset
call inst$getstructfieldi2
}
macro getstructfieldi4 offset* {
mov ecx, offset
call inst$getstructfieldi4
}
macro getstructfieldi8 offset* {
mov ecx, offset
call inst$getstructfieldi8
}
macro getstructfieldl offset* {
mov ecx, offset
call inst$getstructfieldl
}
macro getstructfieldl2 offset* {
mov ecx, offset
call inst$getstructfieldl2
}
macro getstructfieldl4 offset* {
mov ecx, offset
call inst$getstructfieldl4
}
macro getstructfieldl8 offset* {
mov ecx, offset
call inst$getstructfieldl8
}
macro getstructfieldf offset* {
mov ecx, offset
call inst$getstructfieldf
}
macro getstructfieldf2 offset* {
mov ecx, offset
call inst$getstructfieldf2
}
macro getstructfieldf4 offset* {
mov ecx, offset
call inst$getstructfieldf4
}
macro getstructfieldf8 offset* {
mov ecx, offset
call inst$getstructfieldf8
}
macro getstructfieldd offset* {
mov ecx, offset
call inst$getstructfieldd
}
macro getstructfieldd2 offset* {
mov ecx, offset
call inst$getstructfieldd2
}
macro getstructfieldd4 offset* {
mov ecx, offset
call inst$getstructfieldd4
}
macro getstructfieldd8 offset* {
mov ecx, offset
call inst$getstructfieldd8
}
macro getstructfieldb offset* {
mov ecx, offset
call inst$getstructfieldb
}
macro getstructfieldb2 offset* {
mov ecx, offset
call inst$getstructfieldb2
}
macro getstructfieldb4 offset* {
mov ecx, offset
call inst$getstructfieldb4
}
macro getstructfieldb8 offset* {
mov ecx, offset
call inst$getstructfieldb8
}
macro getstructfields offset* {
mov ecx, offset
call inst$getstructfields
}
macro getstructfields2 offset* {
mov ecx, offset
call inst$getstructfields2
}
macro getstructfields4 offset* {
mov ecx, offset
call inst$getstructfields4
}
macro getstructfields8 offset* {
mov ecx, offset
call inst$getstructfields8
}
macro getstructfieldx offset* {
mov ecx, offset
call inst$getstructfieldx
}
macro getstructfieldc offset* {
mov ecx, offset
call inst$getstructfieldc
}
; </fold>
; <fold getarrayelement*>
macro getarrayelementi {
call inst$getarrayelementi
}
macro getarrayelementi2 {
call inst$getarrayelementi2
}
macro getarrayelementi4 {
call inst$getarrayelementi4
}
macro getarrayelementi8 {
call inst$getarrayelementi8
}
macro getarrayelementl {
call inst$getarrayelementl
}
macro getarrayelementl2 {
call inst$getarrayelementl2
}
macro getarrayelementl4 {
call inst$getarrayelementl4
}
macro getarrayelementl8 {
call inst$getarrayelementl8
}
macro getarrayelementf {
call inst$getarrayelementf
}
macro getarrayelementf2 {
call inst$getarrayelementf2
}
macro getarrayelementf4 {
call inst$getarrayelementf4
}
macro getarrayelementf8 {
call inst$getarrayelementf8
}
macro getarrayelementd {
call inst$getarrayelementd
}
macro getarrayelementd2 {
call inst$getarrayelementd2
}
macro getarrayelementd4 {
call inst$getarrayelementd4
}
macro getarrayelementd8 {
call inst$getarrayelementd8
}
macro getarrayelementb {
call inst$getarrayelementb
}
macro getarrayelementb2 {
call inst$getarrayelementb2
}
macro getarrayelementb4 {
call inst$getarrayelementb4
}
macro getarrayelementb8 {
call inst$getarrayelementb8
}
macro getarrayelements {
call inst$getarrayelements
}
macro getarrayelements2 {
call inst$getarrayelements2
}
macro getarrayelements4 {
call inst$getarrayelements4
}
macro getarrayelements8 {
call inst$getarrayelements8
}
macro getarrayelementx {
call inst$getarrayelementx
}
macro getarrayelementc {
call inst$getarrayelementc
}
macro getarrayelementr {
call inst$getarrayelementr
}
; </fold>
; <fold getvectorelement>
macro getvectorelementi2 {
call inst$getvectorelementi2
}
macro getvectorelementi4 {
call inst$getvectorelementi4
}
macro getvectorelementi8 {
call inst$getvectorelementi8
}
macro getvectorelementl2 {
call inst$getvectorelementl2
}
macro getvectorelementl4 {
call inst$getvectorelementl4
}
macro getvectorelementl8 {
call inst$getvectorelementl8
}
macro getvectorelementf2 {
call inst$getvectorelementf2
}
macro getvectorelementf4 {
call inst$getvectorelementf4
}
macro getvectorelementf8 {
call inst$getvectorelementf8
}
macro getvectorelementd2 {
call inst$getvectorelementd2
}
macro getvectorelementd4 {
call inst$getvectorelementd4
}
macro getvectorelementd8 {
call inst$getvectorelementd8
}
macro getvectorelementb2 {
call inst$getvectorelementb2
}
macro getvectorelementb4 {
call inst$getvectorelementb4
}
macro getvectorelementb8 {
call inst$getvectorelementb8
}
macro getvectorelements2 {
call inst$getvectorelements2
}
macro getvectorelements4 {
call inst$getvectorelements4
}
macro getvectorelements8 {
call inst$getvectorelements8
}
; </fold>
; <fold setfield*>
macro setfieldi offset* {
mov ecx, offset
call inst$setfieldi
}
macro setfieldi2 offset* {
mov ecx, offset
call inst$setfieldi2
}
macro setfieldi4 offset* {
mov ecx, offset
call inst$setfieldi4
}
macro setfieldi8 offset* {
mov ecx, offset
call inst$setfieldi8
}
macro setfieldl offset* {
mov ecx, offset
call inst$setfieldl
}
macro setfieldl2 offset* {
mov ecx, offset
call inst$setfieldl2
}
macro setfieldl4 offset* {
mov ecx, offset
call inst$setfieldl4
}
macro setfieldl8 offset* {
mov ecx, offset
call inst$setfieldl8
}
macro setfieldf offset* {
mov ecx, offset
call inst$setfieldf
}
macro setfieldf2 offset* {
mov ecx, offset
call inst$setfieldf2
}
macro setfieldf4 offset* {
mov ecx, offset
call inst$setfieldf4
}
macro setfieldf8 offset* {
mov ecx, offset
call inst$setfieldf8
}
macro setfieldd offset* {
mov ecx, offset
call inst$setfieldd
}
macro setfieldd2 offset* {
mov ecx, offset
call inst$setfieldd2
}
macro setfieldd4 offset* {
mov ecx, offset
call inst$setfieldd4
}
macro setfieldd8 offset* {
mov ecx, offset
call inst$setfieldd8
}
macro setfieldb offset* {
mov ecx, offset
call inst$setfieldb
}
macro setfieldb2 offset* {
mov ecx, offset
call inst$setfieldb2
}
macro setfieldb4 offset* {
mov ecx, offset
call inst$setfieldb4
}
macro setfieldb8 offset* {
mov ecx, offset
call inst$setfieldb8
}
macro setfields offset* {
mov ecx, offset
call inst$setfields
}
macro setfields2 offset* {
mov ecx, offset
call inst$setfields2
}
macro setfields4 offset* {
mov ecx, offset
call inst$setfields4
}
macro setfields8 offset* {
mov ecx, offset
call inst$setfields8
}
macro setfieldx offset* {
mov ecx, offset
call inst$setfieldx
}
macro setfieldc offset* {
mov ecx, offset
call inst$setfieldc
}
macro setfieldr offset* {
mov ecx, offset
call inst$setfieldr
}
; </fold>
; <fold setstructfield*>
macro setstructfieldi offset* {
mov ecx, offset
call inst$setstructfieldi
}
macro setstructfieldi2 offset* {
mov ecx, offset
call inst$setstructfieldi2
}
macro setstructfieldi4 offset* {
mov ecx, offset
call inst$setstructfieldi4
}
macro setstructfieldi8 offset* {
mov ecx, offset
call inst$setstructfieldi8
}
macro setstructfieldl offset* {
mov ecx, offset
call inst$setstructfieldl
}
macro setstructfieldl2 offset* {
mov ecx, offset
call inst$setstructfieldl2
}
macro setstructfieldl4 offset* {
mov ecx, offset
call inst$setstructfieldl4
}
macro setstructfieldl8 offset* {
mov ecx, offset
call inst$setstructfieldl8
}
macro setstructfieldf offset* {
mov ecx, offset
call inst$setstructfieldf
}
macro setstructfieldf2 offset* {
mov ecx, offset
call inst$setstructfieldf2
}
macro setstructfieldf4 offset* {
mov ecx, offset
call inst$setstructfieldf4
}
macro setstructfieldf8 offset* {
mov ecx, offset
call inst$setstructfieldf8
}
macro setstructfieldd offset* {
mov ecx, offset
call inst$setstructfieldd
}
macro setstructfieldd2 offset* {
mov ecx, offset
call inst$setstructfieldd2
}
macro setstructfieldd4 offset* {
mov ecx, offset
call inst$setstructfieldd4
}
macro setstructfieldd8 offset* {
mov ecx, offset
call inst$setstructfieldd8
}
macro setstructfieldb offset* {
mov ecx, offset
call inst$setstructfieldb
}
macro setstructfieldb2 offset* {
mov ecx, offset
call inst$setstructfieldb2
}
macro setstructfieldb4 offset* {
mov ecx, offset
call inst$setstructfieldb4
}
macro setstructfieldb8 offset* {
mov ecx, offset
call inst$setstructfieldb8
}
macro setstructfields offset* {
mov ecx, offset
call inst$setstructfields
}
macro setstructfields2 offset* {
mov ecx, offset
call inst$setstructfields2
}
macro setstructfields4 offset* {
mov ecx, offset
call inst$setstructfields4
}
macro setstructfields8 offset* {
mov ecx, offset
call inst$setstructfields8
}
macro setstructfieldx offset* {
mov ecx, offset
call inst$setstructfieldx
}
macro setstructfieldc offset* {
mov ecx, offset
call inst$setstructfieldc
}
; </fold>
; <fold setarrayelement*>
macro setarrayelementi {
call inst$setarrayelementi
}
macro setarrayelementi2 {
call inst$setarrayelementi2
}
macro setarrayelementi4 {
call inst$setarrayelementi4
}
macro setarrayelementi8 {
call inst$setarrayelementi8
}
macro setarrayelementl {
call inst$setarrayelementl
}
macro setarrayelementl2 {
call inst$setarrayelementl2
}
macro setarrayelementl4 {
call inst$setarrayelementl4
}
macro setarrayelementl8 {
call inst$setarrayelementl8
}
macro setarrayelementf {
call inst$setarrayelementf
}
macro setarrayelementf2 {
call inst$setarrayelementf2
}
macro setarrayelementf4 {
call inst$setarrayelementf4
}
macro setarrayelementf8 {
call inst$setarrayelementf8
}
macro setarrayelementd {
call inst$setarrayelementd
}
macro setarrayelementd2 {
call inst$setarrayelementd2
}
macro setarrayelementd4 {
call inst$setarrayelementd4
}
macro setarrayelementd8 {
call inst$setarrayelementd8
}
macro setarrayelementb {
call inst$setarrayelementb
}
macro setarrayelementb2 {
call inst$setarrayelementb2
}
macro setarrayelementb4 {
call inst$setarrayelementb4
}
macro setarrayelementb8 {
call inst$setarrayelementb8
}
macro setarrayelements {
call inst$setarrayelements
}
macro setarrayelements2 {
call inst$setarrayelements2
}
macro setarrayelements4 {
call inst$setarrayelements4
}
macro setarrayelements8 {
call inst$setarrayelements8
}
macro setarrayelementx {
call inst$setarrayelementx
}
macro setarrayelementc {
call inst$setarrayelementc
}
macro setarrayelementr {
invokespecial avt.lang.Object.01d$$awr$$int$avt.lang.Object$
}
; </fold>
; <fold invokefinally>
macro invokefinally blockLabel* {
call blockLabel
}
; </fold>
; <fold invokestatic*>
macro stackcheck bytes {
if(bytes eq)
mov ecx, $20
else
mov ecx, bytes
end if
call inst$stackcheck
}
macro invokestatic methodFullName* {
stackcheck
call methodFullName
}
macro invokestaticd methodFullName* {
invokestatic methodFullName
call inst$resultpushd
}
macro invokestaticq methodFullName* {
invokestatic methodFullName
call inst$resultpushq
}
macro invokestatict methodFullName* {
invokestatic methodFullName
call inst$resultpusht
}
macro invokestaticx methodFullName* {
invokestatic methodFullName
call inst$resultpushx
}
macro invokestaticy methodFullName* {
invokestatic methodFullName
call inst$resultpushy
}
macro invokestaticz methodFullName* {
invokestatic methodFullName
call inst$resultpushz
}
macro invokestaticr methodFullName* {
invokestatic methodFullName
call inst$resultpushr
}
; macro resultdiscard {
; call inst$resultdiscard
; }
; </fold>
; <fold invokespecial*>
macro nullcheck offset* {
mov ecx, offset
call inst$nullcheck
}
macro invokespecial methodFullName* {
nullcheck methodFullName#.tag.arg-$01
invokestatic methodFullName
}
macro invokespeciald methodFullName* {
nullcheck methodFullName#.tag.arg-$01
invokestaticd methodFullName
}
macro invokespecialq methodFullName* {
nullcheck methodFullName#.tag.arg-$01
invokestaticq methodFullName
}
macro invokespecialt methodFullName* {
nullcheck methodFullName#.tag.arg-$01
invokestatict methodFullName
}
macro invokespecialx methodFullName* {
nullcheck methodFullName#.tag.arg-$01
invokestaticx methodFullName
}
macro invokespecialy methodFullName* {
nullcheck methodFullName#.tag.arg-$01
invokestaticy methodFullName
}
macro invokespecialz methodFullName* {
nullcheck methodFullName#.tag.arg-$01
invokestaticz methodFullName
}
macro invokespecialr methodFullName* {
nullcheck methodFullName#.tag.arg-$01
invokestaticr methodFullName
}
; </fold>
; <fold invokevirtual*>
macro virtualmethod virtualIndex* {
add rax, [rax+avt.lang.Object$fldClassOffset]
movsxd rcx, [rax+avt.lang.Class$fldVirtualsOffset]
lea rax, [rax+rcx*1]
add rax, [rax+virtualIndex*8]
}
macro invokevirtual methodFullName*, virtualIndex* {
nullcheck methodFullName#.tag.arg-$01
stackcheck
virtualmethod virtualIndex
call rax
}
macro invokevirtuald methodFullName*, virtualIndex* {
invokevirtual methodFullName, virtualIndex
call inst$resultpushd
}
macro invokevirtualq methodFullName*, virtualIndex* {
invokevirtual methodFullName, virtualIndex
call inst$resultpushq
}
macro invokevirtualt methodFullName*, virtualIndex* {
invokevirtual methodFullName, virtualIndex
call inst$resultpusht
}
macro invokevirtualx methodFullName*, virtualIndex* {
invokevirtual methodFullName, virtualIndex
call inst$resultpushx
}
macro invokevirtualy methodFullName*, virtualIndex* {
invokevirtual methodFullName, virtualIndex
call inst$resultpushy
}
macro invokevirtualz methodFullName*, virtualIndex* {
invokevirtual methodFullName, virtualIndex
call inst$resultpushz
}
macro invokevirtualr methodFullName*, virtualIndex* {
invokevirtual methodFullName, virtualIndex
call inst$resultpushr
}
; </fold>
; <fold invokeservice*>
macro servicemethod classFullName*, serviceIndex* {
add rax, [rax+avt.lang.Object$fldClassOffset]
call inst$rpush
rloadclass classFullName
iload serviceIndex*$20
invokestatic avt.lang.Class$getServiceMethodEntryPoint$avt.lang.Class$int$
}
macro invokeservice classFullName*, methodShortName*, serviceIndex* {
nullcheck classFullName#$#methodShortName#.tag.arg-$01
servicemethod classFullName, serviceIndex
call rax
}
macro invokeserviced classFullName*, methodShortName*, serviceIndex* {
invokeservice classFullName, methodShortName, serviceIndex
call inst$resultpushd
}
macro invokeserviceq classFullName*, methodShortName*, serviceIndex* {
invokeservice classFullName, methodShortName, serviceIndex
call inst$resultpushq
}
macro invokeservicet classFullName*, methodShortName*, serviceIndex* {
invokeservice classFullName, methodShortName, serviceIndex
call inst$resultpusht
}
macro invokeservicex classFullName*, methodShortName*, serviceIndex* {
invokeservice classFullName, methodShortName, serviceIndex
call inst$resultpushx
}
macro invokeservicey classFullName*, methodShortName*, serviceIndex* {
invokeservice classFullName, methodShortName, serviceIndex
call inst$resultpushy
}
macro invokeservicez classFullName*, methodShortName*, serviceIndex* {
invokeservice classFullName, methodShortName, serviceIndex
call inst$resultpushz
}
macro invokeservicer classFullName*, methodShortName*, serviceIndex* {
invokeservice classFullName, methodShortName, serviceIndex
call inst$resultpushr
}
; </fold>
; <fold jump*>
macro jumpspecial methodFullName* {
local .L.000
local .L.001
.L.000: jmp methodFullName
.L.001: nopvar $20-(.L.001-.L.000)
}
macro jumpvirtual methodFullName*, virtualIndex* {
local .L.000
local .L.001
.L.000: mov rax, [rsp+methodFullName#.size.arg-$08]
virtualmethod virtualIndex
jmp rax
.L.001: nopvar $20-(.L.001-.L.000)
}
; </fold>
; <fold new*>
macro newarray classFullName* {
lea rax, [classFullName]
call inst$rpull1
invokestaticr avt.lang.Class$allocateArray$int$
}
macro newmultiarray classFullName* {
lea rax, [classFullName]
call inst$rpull1
invokestaticr avt.lang.Class$allocateArray$int.01d$
}
macro newclass classFullName* {
rloadclass classFullName
invokestaticr avt.lang.Class$allocateInstance$
}
macro newvectori2 {
call inst$newvectori2
}
macro newvectori4 {
call inst$newvectori4
}
macro newvectori8 {
call inst$newvectori8
}
macro newvectorl2 {
call inst$newvectorl2
}
macro newvectorl4 {
call inst$newvectorl4
}
macro newvectorl8 {
call inst$newvectorl8
}
macro newvectorf2 {
call inst$newvectorf2
}
macro newvectorf4 {
call inst$newvectorf4
}
macro newvectorf8 {
call inst$newvectorf8
}
macro newvectord2 {
call inst$newvectord2
}
macro newvectord4 {
call inst$newvectord4
}
macro newvectord8 {
call inst$newvectord8
}
macro newvectorb2 {
call inst$newvectorb2
}
macro newvectorb4 {
call inst$newvectorb4
}
macro newvectorb8 {
call inst$newvectorb8
}
macro newvectors2 {
call inst$newvectors2
}
macro newvectors4 {
call inst$newvectors4
}
macro newvectors8 {
call inst$newvectors8
}
; </fold>
; <fold dup*>
macro dup1 {
call inst$dup1
}
macro dup1x1 {
call inst$dup1x1
}
macro dup1x2 {
call inst$dup1x2
}
macro dup2 {
call inst$dup2
}
; </fold>
; <fold pop1>
macro pop1 {
call inst$pop1
}
; </fold>
; <fold rmonitor*>
macro rmonitorenter {
invokespecial avt.lang.Object$lock$
}
macro rmonitorleave {
invokespecial avt.lang.Object$unlock$
}
; </fold>
; <fold re>
macro re {
call inst$re
}
; </fold>
; <fold rne>
macro rne {
call inst$rne
}
; </fold>
; <fold risnull>
macro risnull {
call inst$risnull
}
; </fold>
; <fold risnotnull>
macro risnotnull {
call inst$risnotnull
}
; </fold>
; <fold rinstanceof>
macro rinstanceof classFullName* {
lea rax, [classFullName]
call inst$rpull1
invokestaticd avt.lang.Class$isInstance$avt.lang.Object$
}
; </fold>
; <fold rcast>
macro rcast classFullName* {
lea rax, [classFullName]
call inst$rpull1
invokestaticr avt.lang.Class$cast$avt.lang.Object$
}
; </fold>
; <fold rthrow>
macro rthrow {
call inst$rthrow
}
; </fold>
; <fold jmp>
; используется инструкция jmp
; </fold>
; <fold ijmp*>
macro ijmpt lbl* {
call inst$ipop
test eax, eax
jnz lbl
}
macro ijmpf lbl* {
call inst$ipop
test eax, eax
jz lbl
}
macro ijmpg lbl* {
call inst$ipop
cmp eax, $00
jg lbl
}
macro ijmpge lbl* {
call inst$ipop
cmp eax, $00
jge lbl
}
macro ijmpl lbl* {
call inst$ipop
cmp eax, $00
jl lbl
}
macro ijmple lbl* {
call inst$ipop
cmp eax, $00
jle lbl
}
macro ijmpe lbl* {
call inst$ipop
cmp eax, $00
je lbl
}
macro ijmpnt lbl* {
call inst$ipop
test eax, eax
jz lbl
}
macro ijmpnf lbl* {
call inst$ipop
test eax, eax
jnz lbl
}
macro ijmpng lbl* {
call inst$ipop
cmp eax, $00
jng lbl
}
macro ijmpnge lbl* {
call inst$ipop
cmp eax, $00
jnge lbl
}
macro ijmpnl lbl* {
call inst$ipop
cmp eax, $00
jnl lbl
}
macro ijmpnle lbl* {
call inst$ipop
cmp eax, $00
jnle lbl
}
macro ijmpne lbl* {
call inst$ipop
cmp eax, $00
jne lbl
}
; </fold>
; <fold iset*>
macro isetg {
call inst$ipeek
cmp eax, $00
setg al
movzx eax, al
mov dword[rsp], eax
}
macro isetge {
call inst$ipeek
cmp eax, $00
setge al
movzx eax, al
mov dword[rsp], eax
}
macro isetl {
call inst$ipeek
cmp eax, $00
setl al
movzx eax, al
mov dword[rsp], eax
}
macro isetle {
call inst$ipeek
cmp eax, $00
setle al
movzx eax, al
mov dword[rsp], eax
}
macro isete {
call inst$ipeek
cmp eax, $00
sete al
movzx eax, al
mov dword[rsp], eax
}
macro isetng {
call inst$ipeek
cmp eax, $00
setng al
movzx eax, al
mov dword[rsp], eax
}
macro isetnge {
call inst$ipeek
cmp eax, $00
setnge al
movzx eax, al
mov dword[rsp], eax
}
macro isetnl {
call inst$ipeek
cmp eax, $00
setnl al
movzx eax, al
mov dword[rsp], eax
}
macro isetnle {
call inst$ipeek
cmp eax, $00
setnle al
movzx eax, al
mov dword[rsp], eax
}
macro isetne {
call inst$ipeek
cmp eax, $00
setne al
movzx eax, al
mov dword[rsp], eax
}
; </fold>
; <fold *to*>
macro itob {
call inst$itob
}
macro itos {
call inst$itos
}
macro itoi2 {
call inst$itoi2
}
macro itoi4 {
call inst$itoi4
}
macro itoi8 {
call inst$itoi8
}
macro itol {
call inst$itol
}
macro itof {
call inst$itof
}
macro itod {
call inst$itod
}
macro itox {
call inst$itox
}
macro itoc {
call inst$itoc
}
macro i2tob2 {
call inst$i2tob2
}
macro i2tos2 {
call inst$i2tos2
}
macro i2toi {
call inst$i2toi
}
macro i2toi4 {
call inst$i2toi4
}
macro i2toi8 {
call inst$i2toi8
}
macro i2tol2 {
call inst$i2tol2
}
macro i2tof2 {
call inst$i2tof2
}
macro i2tod2 {
call inst$i2tod2
}
macro i4tob4 {
call inst$i4tob4
}
macro i4tos4 {
call inst$i4tos4
}
macro i4toi {
call inst$i4toi
}
macro i4toi2 {
call inst$i4toi2
}
macro i4toi8 {
call inst$i4toi8
}
macro i4tol4 {
call inst$i4tol4
}
macro i4tof4 {
call inst$i4tof4
}
macro i4tod4 {
call inst$i4tod4
}
macro i8tob8 {
call inst$i8tob8
}
macro i8tos8 {
call inst$i8tos8
}
macro i8toi {
call inst$i8toi
}
macro i8toi2 {
call inst$i8toi2
}
macro i8toi4 {
call inst$i8toi4
}
macro i8tol8 {
call inst$i8tol8
}
macro i8tof8 {
call inst$i8tof8
}
macro i8tod8 {
call inst$i8tod8
}
macro ltob {
call inst$ltob
}
macro ltos {
call inst$ltos
}
macro ltoi {
call inst$ltoi
}
macro ltol2 {
call inst$ltol2
}
macro ltol4 {
call inst$ltol4
}
macro ltol8 {
call inst$ltol8
}
macro ltof {
call inst$ltof
}
macro ltod {
call inst$ltod
}
macro ltox {
call inst$ltox
}
macro l2tob2 {
call inst$l2tob2
}
macro l2tos2 {
call inst$l2tos2
}
macro l2toi2 {
call inst$l2toi2
}
macro l2tol {
call inst$l2tol
}
macro l2tol4 {
call inst$l2tol4
}
macro l2tol8 {
call inst$l2tol8
}
macro l2tof2 {
call inst$l2tof2
}
macro l2tod2 {
call inst$l2tod2
}
macro l4tob4 {
call inst$l4tob4
}
macro l4tos4 {
call inst$l4tos4
}
macro l4toi4 {
call inst$l4toi4
}
macro l4tol {
call inst$l4tol
}
macro l4tol2 {
call inst$l4tol2
}
macro l4tol8 {
call inst$l4tol8
}
macro l4tof4 {
call inst$l4tof4
}
macro l4tod4 {
call inst$l4tod4
}
macro l8tob8 {
call inst$l8tob8
}
macro l8tos8 {
call inst$l8tos8
}
macro l8toi8 {
call inst$l8toi8
}
macro l8tol {
call inst$l8tol
}
macro l8tol2 {
call inst$l8tol2
}
macro l8tol4 {
call inst$l8tol4
}
macro l8tof8 {
call inst$l8tof8
}
macro l8tod8 {
call inst$l8tod8
}
macro ftoi {
call inst$ftoi
}
macro ftol {
call inst$ftol
}
macro ftof2 {
call inst$ftof2
}
macro ftof4 {
call inst$ftof4
}
macro ftof8 {
call inst$ftof8
}
macro ftod {
call inst$ftod
}
macro ftox {
call inst$ftox
}
macro f2toi2 {
call inst$f2toi2
}
macro f2tol2 {
call inst$f2tol2
}
macro f2tof {
call inst$f2tof
}
macro f2tof4 {
call inst$f2tof4
}
macro f2tof8 {
call inst$f2tof8
}
macro f2tod2 {
call inst$f2tod2
}
macro f4toi4 {
call inst$f4toi4
}
macro f4tol4 {
call inst$f4tol4
}
macro f4tof {
call inst$f4tof
}
macro f4tof2 {
call inst$f4tof2
}
macro f4tof8 {
call inst$f4tof8
}
macro f4tod4 {
call inst$f4tod4
}
macro f8toi8 {
call inst$f8toi8
}
macro f8tol8 {
call inst$f8tol8
}
macro f8tof {
call inst$f8tof
}
macro f8tof2 {
call inst$f8tof2
}
macro f8tof4 {
call inst$f8tof4
}
macro f8tod8 {
call inst$f8tod8
}
macro dtoi {
call inst$dtoi
}
macro dtol {
call inst$dtol
}
macro dtof {
call inst$dtof
}
macro dtod2 {
call inst$dtod2
}
macro dtod4 {
call inst$dtod4
}
macro dtod8 {
call inst$dtod8
}
macro dtox {
call inst$dtox
}
macro d2toi2 {
call inst$d2toi2
}
macro d2tol2 {
call inst$d2tol2
}
macro d2tof2 {
call inst$d2tof2
}
macro d2tod {
call inst$d2tod
}
macro d2tod4 {
call inst$d2tod4
}
macro d2tod8 {
call inst$d2tod8
}
macro d4toi4 {
call inst$d4toi4
}
macro d4tol4 {
call inst$d4tol4
}
macro d4tof4 {
call inst$d4tof4
}
macro d4tod {
call inst$d4tod
}
macro d4tod2 {
call inst$d4tod2
}
macro d4tod8 {
call inst$d4tod8
}
macro d8toi8 {
call inst$d8toi8
}
macro d8tol8 {
call inst$d8tol8
}
macro d8tof8 {
call inst$d8tof8
}
macro d8tod {
call inst$d8tod
}
macro d8tod2 {
call inst$d8tod2
}
macro d8tod4 {
call inst$d8tod4
}
macro btob2 {
call inst$btob2
}
macro btob4 {
call inst$btob4
}
macro btob8 {
call inst$btob8
}
macro btos {
call inst$btos
}
macro btoi {
call inst$btoi
}
macro btol {
call inst$btol
}
macro b2tob {
call inst$b2tob
}
macro b2tob4 {
call inst$b2tob4
}
macro b2tob8 {
call inst$b2tob8
}
macro b2tos2 {
call inst$b2tos2
}
macro b2toi2 {
call inst$b2toi2
}
macro b2tol2 {
call inst$b2tol2
}
macro b4tob {
call inst$b4tob
}
macro b4tob2 {
call inst$b4tob2
}
macro b4tob8 {
call inst$b4tob8
}
macro b4tos4 {
call inst$b4tos4
}
macro b4toi4 {
call inst$b4toi4
}
macro b4tol4 {
call inst$b4tol4
}
macro b8tob {
call inst$b8tob
}
macro b8tob2 {
call inst$b8tob2
}
macro b8tob4 {
call inst$b8tob4
}
macro b8tos8 {
call inst$b8tos8
}
macro b8toi8 {
call inst$b8toi8
}
macro b8tol8 {
call inst$b8tol8
}
macro stob {
call inst$stob
}
macro stos2 {
call inst$stos2
}
macro stos4 {
call inst$stos4
}
macro stos8 {
call inst$stos8
}
macro stoi {
call inst$stoi
}
macro stol {
call inst$stol
}
macro s2tob2 {
call inst$s2tob2
}
macro s2tos {
call inst$s2tos
}
macro s2tos4 {
call inst$s2tos4
}
macro s2tos8 {
call inst$s2tos8
}
macro s2toi2 {
call inst$s2toi2
}
macro s2tol2 {
call inst$s2tol2
}
macro s4tob4 {
call inst$s4tob4
}
macro s4tos {
call inst$s4tos
}
macro s4tos2 {
call inst$s4tos2
}
macro s4tos8 {
call inst$s4tos8
}
macro s4toi4 {
call inst$s4toi4
}
macro s4tol4 {
call inst$s4tol4
}
macro s8tob8 {
call inst$s8tob8
}
macro s8tos {
call inst$s8tos
}
macro s8tos2 {
call inst$s8tos2
}
macro s8tos4 {
call inst$s8tos4
}
macro s8toi8 {
call inst$s8toi8
}
macro s8tol8 {
call inst$s8tol8
}
macro xtoi {
call inst$xtoi
}
macro xtol {
call inst$xtol
}
macro xtof {
call inst$xtof
}
macro xtod {
call inst$xtod
}
; </fold>
; <fold *cmp*>
macro icmp {
call inst$icmp
}
macro lcmp {
call inst$lcmp
}
macro fcmpg {
call inst$fcmpg
}
macro fcmpl {
call inst$fcmpl
}
macro dcmpg {
call inst$dcmpg
}
macro dcmpl {
call inst$dcmpl
}
macro xcmpg {
call inst$xcmpg
}
macro xcmpl {
call inst$xcmpl
}
; </fold>
; <fold *se>
macro i2se {
call inst$i2se
}
macro i4se {
call inst$i4se
}
macro i8se {
call inst$i8se
}
macro l2se {
call inst$l2se
}
macro l4se {
call inst$l4se
}
macro l8se {
call inst$l8se
}
macro f2se {
call inst$f2se
}
macro f4se {
call inst$f4se
}
macro f8se {
call inst$f8se
}
macro d2se {
call inst$d2se
}
macro d4se {
call inst$d4se
}
macro d8se {
call inst$d8se
}
macro b2se {
call inst$b2se
}
macro b4se {
call inst$b4se
}
macro b8se {
call inst$b8se
}
macro s2se {
call inst$s2se
}
macro s4se {
call inst$s4se
}
macro s8se {
call inst$s8se
}
; </fold>
; <fold *sne>
macro i2sne {
call inst$i2sne
}
macro i4sne {
call inst$i4sne
}
macro i8sne {
call inst$i8sne
}
macro l2sne {
call inst$l2sne
}
macro l4sne {
call inst$l4sne
}
macro l8sne {
call inst$l8sne
}
macro f2sne {
call inst$f2sne
}
macro f4sne {
call inst$f4sne
}
macro f8sne {
call inst$f8sne
}
macro d2sne {
call inst$d2sne
}
macro d4sne {
call inst$d4sne
}
macro d8sne {
call inst$d8sne
}
macro b2sne {
call inst$b2sne
}
macro b4sne {
call inst$b4sne
}
macro b8sne {
call inst$b8sne
}
macro s2sne {
call inst$s2sne
}
macro s4sne {
call inst$s4sne
}
macro s8sne {
call inst$s8sne
}
; </fold>
; <fold *not>
macro inot {
call inst$inot
}
macro i2not {
call inst$i2not
}
macro i4not {
call inst$i4not
}
macro i8not {
call inst$i8not
}
macro lnot {
call inst$lnot
}
macro l2not {
call inst$l2not
}
macro l4not {
call inst$l4not
}
macro l8not {
call inst$l8not
}
macro bnot {
call inst$bnot
}
macro b2not {
call inst$b2not
}
macro b4not {
call inst$b4not
}
macro b8not {
call inst$b8not
}
macro snot {
call inst$snot
}
macro s2not {
call inst$s2not
}
macro s4not {
call inst$s4not
}
macro s8not {
call inst$s8not
}
; </fold>
; <fold *and>
macro iand {
call inst$iand
}
macro i2and {
call inst$i2and
}
macro i4and {
call inst$i4and
}
macro i8and {
call inst$i8and
}
macro land {
call inst$land
}
macro l2and {
call inst$l2and
}
macro l4and {
call inst$l4and
}
macro l8and {
call inst$l8and
}
macro band {
call inst$band
}
macro b2and {
call inst$b2and
}
macro b4and {
call inst$b4and
}
macro b8and {
call inst$b8and
}
macro sand {
call inst$sand
}
macro s2and {
call inst$s2and
}
macro s4and {
call inst$s4and
}
macro s8and {
call inst$s8and
}
; </fold>
; <fold *or>
macro ior {
call inst$ior
}
macro i2or {
call inst$i2or
}
macro i4or {
call inst$i4or
}
macro i8or {
call inst$i8or
}
macro lor {
call inst$lor
}
macro l2or {
call inst$l2or
}
macro l4or {
call inst$l4or
}
macro l8or {
call inst$l8or
}
macro bor {
call inst$bor
}
macro b2or {
call inst$b2or
}
macro b4or {
call inst$b4or
}
macro b8or {
call inst$b8or
}
macro sor {
call inst$sor
}
macro s2or {
call inst$s2or
}
macro s4or {
call inst$s4or
}
macro s8or {
call inst$s8or
}
; </fold>
; <fold *xor>
macro ixor {
call inst$ixor
}
macro i2xor {
call inst$i2xor
}
macro i4xor {
call inst$i4xor
}
macro i8xor {
call inst$i8xor
}
macro lxor {
call inst$lxor
}
macro l2xor {
call inst$l2xor
}
macro l4xor {
call inst$l4xor
}
macro l8xor {
call inst$l8xor
}
macro bxor {
call inst$bxor
}
macro b2xor {
call inst$b2xor
}
macro b4xor {
call inst$b4xor
}
macro b8xor {
call inst$b8xor
}
macro sxor {
call inst$sxor
}
macro s2xor {
call inst$s2xor
}
macro s4xor {
call inst$s4xor
}
macro s8xor {
call inst$s8xor
}
; </fold>
; <fold *sneg>
macro isneg {
call inst$isneg
}
macro i2sneg {
call inst$i2sneg
}
macro i4sneg {
call inst$i4sneg
}
macro i8sneg {
call inst$i8sneg
}
macro lsneg {
call inst$lsneg
}
macro l2sneg {
call inst$l2sneg
}
macro l4sneg {
call inst$l4sneg
}
macro l8sneg {
call inst$l8sneg
}
macro fsneg {
call inst$fsneg
}
macro f2sneg {
call inst$f2sneg
}
macro f4sneg {
call inst$f4sneg
}
macro f8sneg {
call inst$f8sneg
}
macro dsneg {
call inst$dsneg
}
macro d2sneg {
call inst$d2sneg
}
macro d4sneg {
call inst$d4sneg
}
macro d8sneg {
call inst$d8sneg
}
macro b2sneg {
call inst$b2sneg
}
macro b4sneg {
call inst$b4sneg
}
macro b8sneg {
call inst$b8sneg
}
macro s2sneg {
call inst$s2sneg
}
macro s4sneg {
call inst$s4sneg
}
macro s8sneg {
call inst$s8sneg
}
macro xsneg {
call inst$xsneg
}
; </fold>
; <fold *smul>
macro ismul {
call inst$ismul
}
macro i2smul {
call inst$i2smul
}
macro i4smul {
call inst$i4smul
}
macro i8smul {
call inst$i8smul
}
macro lsmul {
call inst$lsmul
}
macro l2smul {
call inst$l2smul
}
macro l4smul {
call inst$l4smul
}
macro l8smul {
call inst$l8smul
}
macro fsmul {
call inst$fsmul
}
macro f2smul {
call inst$f2smul
}
macro f4smul {
call inst$f4smul
}
macro f8smul {
call inst$f8smul
}
macro dsmul {
call inst$dsmul
}
macro d2smul {
call inst$d2smul
}
macro d4smul {
call inst$d4smul
}
macro d8smul {
call inst$d8smul
}
macro b2smul {
call inst$b2smul
}
macro b4smul {
call inst$b4smul
}
macro b8smul {
call inst$b8smul
}
macro s2smul {
call inst$s2smul
}
macro s4smul {
call inst$s4smul
}
macro s8smul {
call inst$s8smul
}
macro xsmul {
call inst$xsmul
}
; </fold>
; <fold *sdiv>
macro isdiv {
call inst$isdiv
}
macro lsdiv {
call inst$lsdiv
}
macro fsdiv {
call inst$fsdiv
}
macro f2sdiv {
call inst$f2sdiv
}
macro f4sdiv {
call inst$f4sdiv
}
macro f8sdiv {
call inst$f8sdiv
}
macro dsdiv {
call inst$dsdiv
}
macro d2sdiv {
call inst$d2sdiv
}
macro d4sdiv {
call inst$d4sdiv
}
macro d8sdiv {
call inst$d8sdiv
}
macro xsdiv {
call inst$xsdiv
}
; </fold>
; <fold *sdivu>
macro isdivu {
call inst$isdivu
}
macro lsdivu {
call inst$lsdivu
}
macro fsdivu {
call inst$fsdivu
}
macro f2sdivu {
call inst$f2sdivu
}
macro f4sdivu {
call inst$f4sdivu
}
macro f8sdivu {
call inst$f8sdivu
}
macro dsdivu {
call inst$dsdivu
}
macro d2sdivu {
call inst$d2sdivu
}
macro d4sdivu {
call inst$d4sdivu
}
macro d8sdivu {
call inst$d8sdivu
}
macro xsdivu {
call inst$xsdivu
}
; </fold>
; <fold *srem>
macro isrem {
call inst$isrem
}
macro lsrem {
call inst$lsrem
}
macro fsrem {
call inst$fsrem
}
macro dsrem {
call inst$dsrem
}
macro xsrem {
call inst$xsrem
}
; </fold>
; <fold *sremu>
macro isremu {
call inst$isremu
}
macro lsremu {
call inst$lsremu
}
macro fsremu {
call inst$fsremu
}
macro dsremu {
call inst$dsremu
}
macro xsremu {
call inst$xsremu
}
; </fold>
; <fold *sadd>
macro isadd {
call inst$isadd
}
macro i2sadd {
call inst$i2sadd
}
macro i4sadd {
call inst$i4sadd
}
macro i8sadd {
call inst$i8sadd
}
macro lsadd {
call inst$lsadd
}
macro l2sadd {
call inst$l2sadd
}
macro l4sadd {
call inst$l4sadd
}
macro l8sadd {
call inst$l8sadd
}
macro fsadd {
call inst$fsadd
}
macro f2sadd {
call inst$f2sadd
}
macro f4sadd {
call inst$f4sadd
}
macro f8sadd {
call inst$f8sadd
}
macro dsadd {
call inst$dsadd
}
macro d2sadd {
call inst$d2sadd
}
macro d4sadd {
call inst$d4sadd
}
macro d8sadd {
call inst$d8sadd
}
macro b2sadd {
call inst$b2sadd
}
macro b4sadd {
call inst$b4sadd
}
macro b8sadd {
call inst$b8sadd
}
macro s2sadd {
call inst$s2sadd
}
macro s4sadd {
call inst$s4sadd
}
macro s8sadd {
call inst$s8sadd
}
macro xsadd {
call inst$xsadd
}
; </fold>
; <fold *ssub>
macro issub {
call inst$issub
}
macro i2ssub {
call inst$i2ssub
}
macro i4ssub {
call inst$i4ssub
}
macro i8ssub {
call inst$i8ssub
}
macro lssub {
call inst$lssub
}
macro l2ssub {
call inst$l2ssub
}
macro l4ssub {
call inst$l4ssub
}
macro l8ssub {
call inst$l8ssub
}
macro fssub {
call inst$fssub
}
macro f2ssub {
call inst$f2ssub
}
macro f4ssub {
call inst$f4ssub
}
macro f8ssub {
call inst$f8ssub
}
macro dssub {
call inst$dssub
}
macro d2ssub {
call inst$d2ssub
}
macro d4ssub {
call inst$d4ssub
}
macro d8ssub {
call inst$d8ssub
}
macro b2ssub {
call inst$b2ssub
}
macro b4ssub {
call inst$b4ssub
}
macro b8ssub {
call inst$b8ssub
}
macro s2ssub {
call inst$s2ssub
}
macro s4ssub {
call inst$s4ssub
}
macro s8ssub {
call inst$s8ssub
}
macro xssub {
call inst$xssub
}
; </fold>
; <fold *ssar>
macro issar {
call inst$issar
}
macro i2ssar {
call inst$i2ssar
}
macro i4ssar {
call inst$i4ssar
}
macro i8ssar {
call inst$i8ssar
}
macro lssar {
call inst$lssar
}
macro l2ssar {
call inst$l2ssar
}
macro l4ssar {
call inst$l4ssar
}
macro l8ssar {
call inst$l8ssar
}
macro b2ssar {
call inst$b2ssar
}
macro b4ssar {
call inst$b4ssar
}
macro b8ssar {
call inst$b8ssar
}
macro s2ssar {
call inst$s2ssar
}
macro s4ssar {
call inst$s4ssar
}
macro s8ssar {
call inst$s8ssar
}
; </fold>
; <fold *ssal>
macro issal {
call inst$issal
}
macro i2ssal {
call inst$i2ssal
}
macro i4ssal {
call inst$i4ssal
}
macro i8ssal {
call inst$i8ssal
}
macro lssal {
call inst$lssal
}
macro l2ssal {
call inst$l2ssal
}
macro l4ssal {
call inst$l4ssal
}
macro l8ssal {
call inst$l8ssal
}
macro b2ssal {
call inst$b2ssal
}
macro b4ssal {
call inst$b4ssal
}
macro b8ssal {
call inst$b8ssal
}
macro s2ssal {
call inst$s2ssal
}
macro s4ssal {
call inst$s4ssal
}
macro s8ssal {
call inst$s8ssal
}
; </fold>
; <fold *sshr>
macro isshr {
call inst$isshr
}
macro i2sshr {
call inst$i2sshr
}
macro i4sshr {
call inst$i4sshr
}
macro i8sshr {
call inst$i8sshr
}
macro lsshr {
call inst$lsshr
}
macro l2sshr {
call inst$l2sshr
}
macro l4sshr {
call inst$l4sshr
}
macro l8sshr {
call inst$l8sshr
}
macro b2sshr {
call inst$b2sshr
}
macro b4sshr {
call inst$b4sshr
}
macro b8sshr {
call inst$b8sshr
}
macro s2sshr {
call inst$s2sshr
}
macro s4sshr {
call inst$s4sshr
}
macro s8sshr {
call inst$s8sshr
}
; </fold>
; <fold *vpack>
macro ivpack {
call inst$ivpack
}
macro i2vpack {
call inst$i2vpack
}
macro i4vpack {
call inst$i4vpack
}
macro i8vpack {
call inst$i8vpack
}
macro lvpack {
call inst$lvpack
}
macro l2vpack {
call inst$l2vpack
}
macro l4vpack {
call inst$l4vpack
}
macro l8vpack {
call inst$l8vpack
}
macro svpack {
call inst$svpack
}
macro s2vpack {
call inst$s2vpack
}
macro s4vpack {
call inst$s4vpack
}
macro s8vpack {
call inst$s8vpack
}
; </fold>
; <fold *vunpckl>
macro ivunpckl {
call inst$ivunpckl
}
macro i2vunpckl {
call inst$i2vunpckl
}
macro i4vunpckl {
call inst$i4vunpckl
}
macro i8vunpckl {
call inst$i8vunpckl
}
macro bvunpckl {
call inst$bvunpckl
}
macro b2vunpckl {
call inst$b2vunpckl
}
macro b4vunpckl {
call inst$b4vunpckl
}
macro b8vunpckl {
call inst$b8vunpckl
}
macro svunpckl {
call inst$svunpckl
}
macro s2vunpckl {
call inst$s2vunpckl
}
macro s4vunpckl {
call inst$s4vunpckl
}
macro s8vunpckl {
call inst$s8vunpckl
}
; </fold>
; <fold *vunpcku>
macro ivunpcku {
call inst$ivunpcku
}
macro i2vunpcku {
call inst$i2vunpcku
}
macro i4vunpcku {
call inst$i4vunpcku
}
macro i8vunpcku {
call inst$i8vunpcku
}
macro bvunpcku {
call inst$bvunpcku
}
macro b2vunpcku {
call inst$b2vunpcku
}
macro b4vunpcku {
call inst$b4vunpcku
}
macro b8vunpcku {
call inst$b8vunpcku
}
macro svunpcku {
call inst$svunpcku
}
macro s2vunpcku {
call inst$s2vunpcku
}
macro s4vunpcku {
call inst$s4vunpcku
}
macro s8vunpcku {
call inst$s8vunpcku
}
; </fold>
; <fold *vneg>
macro ivneg {
call inst$ivneg
}
macro i2vneg {
call inst$i2vneg
}
macro i4vneg {
call inst$i4vneg
}
macro i8vneg {
call inst$i8vneg
}
macro lvneg {
call inst$lvneg
}
macro l2vneg {
call inst$l2vneg
}
macro l4vneg {
call inst$l4vneg
}
macro l8vneg {
call inst$l8vneg
}
macro fvneg {
call inst$fvneg
}
macro f2vneg {
call inst$f2vneg
}
macro f4vneg {
call inst$f4vneg
}
macro f8vneg {
call inst$f8vneg
}
macro dvneg {
call inst$dvneg
}
macro d2vneg {
call inst$d2vneg
}
macro d4vneg {
call inst$d4vneg
}
macro d8vneg {
call inst$d8vneg
}
macro bvneg {
call inst$bvneg
}
macro b2vneg {
call inst$b2vneg
}
macro b4vneg {
call inst$b4vneg
}
macro b8vneg {
call inst$b8vneg
}
macro svneg {
call inst$svneg
}
macro s2vneg {
call inst$s2vneg
}
macro s4vneg {
call inst$s4vneg
}
macro s8vneg {
call inst$s8vneg
}
; </fold>
; <fold *vmul>
macro ivmul {
call inst$ivmul
}
macro i2vmul {
call inst$i2vmul
}
macro i4vmul {
call inst$i4vmul
}
macro i8vmul {
call inst$i8vmul
}
macro lvmul {
call inst$lvmul
}
macro l2vmul {
call inst$l2vmul
}
macro l4vmul {
call inst$l4vmul
}
macro l8vmul {
call inst$l8vmul
}
macro fvmul {
call inst$fvmul
}
macro f2vmul {
call inst$f2vmul
}
macro f4vmul {
call inst$f4vmul
}
macro f8vmul {
call inst$f8vmul
}
macro dvmul {
call inst$dvmul
}
macro d2vmul {
call inst$d2vmul
}
macro d4vmul {
call inst$d4vmul
}
macro d8vmul {
call inst$d8vmul
}
macro bvmul {
call inst$bvmul
}
macro b2vmul {
call inst$b2vmul
}
macro b4vmul {
call inst$b4vmul
}
macro b8vmul {
call inst$b8vmul
}
macro svmul {
call inst$svmul
}
macro s2vmul {
call inst$s2vmul
}
macro s4vmul {
call inst$s4vmul
}
macro s8vmul {
call inst$s8vmul
}
; </fold>
; <fold *vdiv>
macro fvdiv {
call inst$fvdiv
}
macro f2vdiv {
call inst$f2vdiv
}
macro f4vdiv {
call inst$f4vdiv
}
macro f8vdiv {
call inst$f8vdiv
}
macro dvdiv {
call inst$dvdiv
}
macro d2vdiv {
call inst$d2vdiv
}
macro d4vdiv {
call inst$d4vdiv
}
macro d8vdiv {
call inst$d8vdiv
}
; </fold>
; <fold *vadd>
macro ivadd {
call inst$ivadd
}
macro i2vadd {
call inst$i2vadd
}
macro i4vadd {
call inst$i4vadd
}
macro i8vadd {
call inst$i8vadd
}
macro lvadd {
call inst$lvadd
}
macro l2vadd {
call inst$l2vadd
}
macro l4vadd {
call inst$l4vadd
}
macro l8vadd {
call inst$l8vadd
}
macro fvadd {
call inst$fvadd
}
macro f2vadd {
call inst$f2vadd
}
macro f4vadd {
call inst$f4vadd
}
macro f8vadd {
call inst$f8vadd
}
macro dvadd {
call inst$dvadd
}
macro d2vadd {
call inst$d2vadd
}
macro d4vadd {
call inst$d4vadd
}
macro d8vadd {
call inst$d8vadd
}
macro bvadd {
call inst$bvadd
}
macro b2vadd {
call inst$b2vadd
}
macro b4vadd {
call inst$b4vadd
}
macro b8vadd {
call inst$b8vadd
}
macro svadd {
call inst$svadd
}
macro s2vadd {
call inst$s2vadd
}
macro s4vadd {
call inst$s4vadd
}
macro s8vadd {
call inst$s8vadd
}
; </fold>
; <fold *vsub>
macro ivsub {
call inst$ivsub
}
macro i2vsub {
call inst$i2vsub
}
macro i4vsub {
call inst$i4vsub
}
macro i8vsub {
call inst$i8vsub
}
macro lvsub {
call inst$lvsub
}
macro l2vsub {
call inst$l2vsub
}
macro l4vsub {
call inst$l4vsub
}
macro l8vsub {
call inst$l8vsub
}
macro fvsub {
call inst$fvsub
}
macro f2vsub {
call inst$f2vsub
}
macro f4vsub {
call inst$f4vsub
}
macro f8vsub {
call inst$f8vsub
}
macro dvsub {
call inst$dvsub
}
macro d2vsub {
call inst$d2vsub
}
macro d4vsub {
call inst$d4vsub
}
macro d8vsub {
call inst$d8vsub
}
macro bvsub {
call inst$bvsub
}
macro b2vsub {
call inst$b2vsub
}
macro b4vsub {
call inst$b4vsub
}
macro b8vsub {
call inst$b8vsub
}
macro svsub {
call inst$svsub
}
macro s2vsub {
call inst$s2vsub
}
macro s4vsub {
call inst$s4vsub
}
macro s8vsub {
call inst$s8vsub
}
; </fold>
; <fold *vsar>
macro ivsar {
call inst$ivsar
}
macro i2vsar {
call inst$i2vsar
}
macro i4vsar {
call inst$i4vsar
}
macro i8vsar {
call inst$i8vsar
}
macro lvsar {
call inst$lvsar
}
macro l2vsar {
call inst$l2vsar
}
macro l4vsar {
call inst$l4vsar
}
macro l8vsar {
call inst$l8vsar
}
macro bvsar {
call inst$bvsar
}
macro b2vsar {
call inst$b2vsar
}
macro b4vsar {
call inst$b4vsar
}
macro b8vsar {
call inst$b8vsar
}
macro svsar {
call inst$svsar
}
macro s2vsar {
call inst$s2vsar
}
macro s4vsar {
call inst$s4vsar
}
macro s8vsar {
call inst$s8vsar
}
; </fold>
; <fold *vsal>
macro ivsal {
call inst$ivsal
}
macro i2vsal {
call inst$i2vsal
}
macro i4vsal {
call inst$i4vsal
}
macro i8vsal {
call inst$i8vsal
}
macro lvsal {
call inst$lvsal
}
macro l2vsal {
call inst$l2vsal
}
macro l4vsal {
call inst$l4vsal
}
macro l8vsal {
call inst$l8vsal
}
macro bvsal {
call inst$bvsal
}
macro b2vsal {
call inst$b2vsal
}
macro b4vsal {
call inst$b4vsal
}
macro b8vsal {
call inst$b8vsal
}
macro svsal {
call inst$svsal
}
macro s2vsal {
call inst$s2vsal
}
macro s4vsal {
call inst$s4vsal
}
macro s8vsal {
call inst$s8vsal
}
; </fold>
; <fold *vshr>
macro ivshr {
call inst$ivshr
}
macro i2vshr {
call inst$i2vshr
}
macro i4vshr {
call inst$i4vshr
}
macro i8vshr {
call inst$i8vshr
}
macro lvshr {
call inst$lvshr
}
macro l2vshr {
call inst$l2vshr
}
macro l4vshr {
call inst$l4vshr
}
macro l8vshr {
call inst$l8vshr
}
macro bvshr {
call inst$bvshr
}
macro b2vshr {
call inst$b2vshr
}
macro b4vshr {
call inst$b4vshr
}
macro b8vshr {
call inst$b8vshr
}
macro svshr {
call inst$svshr
}
macro s2vshr {
call inst$s2vshr
}
macro s4vshr {
call inst$s4vshr
}
macro s8vshr {
call inst$s8vshr
}
; </fold>
; <fold *vg>
macro ivg {
call inst$ivg
}
macro i2vg {
call inst$i2vg
}
macro i4vg {
call inst$i4vg
}
macro i8vg {
call inst$i8vg
}
macro lvg {
call inst$lvg
}
macro l2vg {
call inst$l2vg
}
macro l4vg {
call inst$l4vg
}
macro l8vg {
call inst$l8vg
}
macro fvg {
call inst$fvg
}
macro f2vg {
call inst$f2vg
}
macro f4vg {
call inst$f4vg
}
macro f8vg {
call inst$f8vg
}
macro dvg {
call inst$dvg
}
macro d2vg {
call inst$d2vg
}
macro d4vg {
call inst$d4vg
}
macro d8vg {
call inst$d8vg
}
macro bvg {
call inst$bvg
}
macro b2vg {
call inst$b2vg
}
macro b4vg {
call inst$b4vg
}
macro b8vg {
call inst$b8vg
}
macro svg {
call inst$svg
}
macro s2vg {
call inst$s2vg
}
macro s4vg {
call inst$s4vg
}
macro s8vg {
call inst$s8vg
}
; </fold>
; <fold *vge>
macro ivge {
call inst$ivge
}
macro i2vge {
call inst$i2vge
}
macro i4vge {
call inst$i4vge
}
macro i8vge {
call inst$i8vge
}
macro lvge {
call inst$lvge
}
macro l2vge {
call inst$l2vge
}
macro l4vge {
call inst$l4vge
}
macro l8vge {
call inst$l8vge
}
macro fvge {
call inst$fvge
}
macro f2vge {
call inst$f2vge
}
macro f4vge {
call inst$f4vge
}
macro f8vge {
call inst$f8vge
}
macro dvge {
call inst$dvge
}
macro d2vge {
call inst$d2vge
}
macro d4vge {
call inst$d4vge
}
macro d8vge {
call inst$d8vge
}
macro bvge {
call inst$bvge
}
macro b2vge {
call inst$b2vge
}
macro b4vge {
call inst$b4vge
}
macro b8vge {
call inst$b8vge
}
macro svge {
call inst$svge
}
macro s2vge {
call inst$s2vge
}
macro s4vge {
call inst$s4vge
}
macro s8vge {
call inst$s8vge
}
; </fold>
; <fold *vl>
macro ivl {
call inst$ivl
}
macro i2vl {
call inst$i2vl
}
macro i4vl {
call inst$i4vl
}
macro i8vl {
call inst$i8vl
}
macro lvl {
call inst$lvl
}
macro l2vl {
call inst$l2vl
}
macro l4vl {
call inst$l4vl
}
macro l8vl {
call inst$l8vl
}
macro fvl {
call inst$fvl
}
macro f2vl {
call inst$f2vl
}
macro f4vl {
call inst$f4vl
}
macro f8vl {
call inst$f8vl
}
macro dvl {
call inst$dvl
}
macro d2vl {
call inst$d2vl
}
macro d4vl {
call inst$d4vl
}
macro d8vl {
call inst$d8vl
}
macro bvl {
call inst$bvl
}
macro b2vl {
call inst$b2vl
}
macro b4vl {
call inst$b4vl
}
macro b8vl {
call inst$b8vl
}
macro svl {
call inst$svl
}
macro s2vl {
call inst$s2vl
}
macro s4vl {
call inst$s4vl
}
macro s8vl {
call inst$s8vl
}
; </fold>
; <fold *vle>
macro ivle {
call inst$ivle
}
macro i2vle {
call inst$i2vle
}
macro i4vle {
call inst$i4vle
}
macro i8vle {
call inst$i8vle
}
macro lvle {
call inst$lvle
}
macro l2vle {
call inst$l2vle
}
macro l4vle {
call inst$l4vle
}
macro l8vle {
call inst$l8vle
}
macro fvle {
call inst$fvle
}
macro f2vle {
call inst$f2vle
}
macro f4vle {
call inst$f4vle
}
macro f8vle {
call inst$f8vle
}
macro dvle {
call inst$dvle
}
macro d2vle {
call inst$d2vle
}
macro d4vle {
call inst$d4vle
}
macro d8vle {
call inst$d8vle
}
macro bvle {
call inst$bvle
}
macro b2vle {
call inst$b2vle
}
macro b4vle {
call inst$b4vle
}
macro b8vle {
call inst$b8vle
}
macro svle {
call inst$svle
}
macro s2vle {
call inst$s2vle
}
macro s4vle {
call inst$s4vle
}
macro s8vle {
call inst$s8vle
}
; </fold>
; <fold *ve>
macro ive {
call inst$ive
}
macro i2ve {
call inst$i2ve
}
macro i4ve {
call inst$i4ve
}
macro i8ve {
call inst$i8ve
}
macro lve {
call inst$lve
}
macro l2ve {
call inst$l2ve
}
macro l4ve {
call inst$l4ve
}
macro l8ve {
call inst$l8ve
}
macro fve {
call inst$fve
}
macro f2ve {
call inst$f2ve
}
macro f4ve {
call inst$f4ve
}
macro f8ve {
call inst$f8ve
}
macro dve {
call inst$dve
}
macro d2ve {
call inst$d2ve
}
macro d4ve {
call inst$d4ve
}
macro d8ve {
call inst$d8ve
}
macro bve {
call inst$bve
}
macro b2ve {
call inst$b2ve
}
macro b4ve {
call inst$b4ve
}
macro b8ve {
call inst$b8ve
}
macro sve {
call inst$sve
}
macro s2ve {
call inst$s2ve
}
macro s4ve {
call inst$s4ve
}
macro s8ve {
call inst$s8ve
}
; </fold>
; <fold *vne>
macro ivne {
call inst$ivne
}
macro i2vne {
call inst$i2vne
}
macro i4vne {
call inst$i4vne
}
macro i8vne {
call inst$i8vne
}
macro lvne {
call inst$lvne
}
macro l2vne {
call inst$l2vne
}
macro l4vne {
call inst$l4vne
}
macro l8vne {
call inst$l8vne
}
macro fvne {
call inst$fvne
}
macro f2vne {
call inst$f2vne
}
macro f4vne {
call inst$f4vne
}
macro f8vne {
call inst$f8vne
}
macro dvne {
call inst$dvne
}
macro d2vne {
call inst$d2vne
}
macro d4vne {
call inst$d4vne
}
macro d8vne {
call inst$d8vne
}
macro bvne {
call inst$bvne
}
macro b2vne {
call inst$b2vne
}
macro b4vne {
call inst$b4vne
}
macro b8vne {
call inst$b8vne
}
macro svne {
call inst$svne
}
macro s2vne {
call inst$s2vne
}
macro s4vne {
call inst$s4vne
}
macro s8vne {
call inst$s8vne
}
; </fold>
; <fold *vmuls>
macro bvmuls {
call inst$bvmuls
}
macro b2vmuls {
call inst$b2vmuls
}
macro b4vmuls {
call inst$b4vmuls
}
macro b8vmuls {
call inst$b8vmuls
}
macro svmuls {
call inst$svmuls
}
macro s2vmuls {
call inst$s2vmuls
}
macro s4vmuls {
call inst$s4vmuls
}
macro s8vmuls {
call inst$s8vmuls
}
; </fold>
; <fold *vadds>
macro bvadds {
call inst$bvadds
}
macro b2vadds {
call inst$b2vadds
}
macro b4vadds {
call inst$b4vadds
}
macro b8vadds {
call inst$b8vadds
}
macro svadds {
call inst$svadds
}
macro s2vadds {
call inst$s2vadds
}
macro s4vadds {
call inst$s4vadds
}
macro s8vadds {
call inst$s8vadds
}
; </fold>
; <fold *vsubs>
macro bvsubs {
call inst$bvsubs
}
macro b2vsubs {
call inst$b2vsubs
}
macro b4vsubs {
call inst$b4vsubs
}
macro b8vsubs {
call inst$b8vsubs
}
macro svsubs {
call inst$svsubs
}
macro s2vsubs {
call inst$s2vsubs
}
macro s4vsubs {
call inst$s4vsubs
}
macro s8vsubs {
call inst$s8vsubs
}
; </fold>
; <fold *vmulu>
macro bvmulu {
call inst$bvmulu
}
macro b2vmulu {
call inst$b2vmulu
}
macro b4vmulu {
call inst$b4vmulu
}
macro b8vmulu {
call inst$b8vmulu
}
macro svmulu {
call inst$svmulu
}
macro s2vmulu {
call inst$s2vmulu
}
macro s4vmulu {
call inst$s4vmulu
}
macro s8vmulu {
call inst$s8vmulu
}
; </fold>
; <fold *vaddu>
macro bvaddu {
call inst$bvaddu
}
macro b2vaddu {
call inst$b2vaddu
}
macro b4vaddu {
call inst$b4vaddu
}
macro b8vaddu {
call inst$b8vaddu
}
macro svaddu {
call inst$svaddu
}
macro s2vaddu {
call inst$s2vaddu
}
macro s4vaddu {
call inst$s4vaddu
}
macro s8vaddu {
call inst$s8vaddu
}
; </fold>
; <fold *vsubu>
macro bvsubu {
call inst$bvsubu
}
macro b2vsubu {
call inst$b2vsubu
}
macro b4vsubu {
call inst$b4vsubu
}
macro b8vsubu {
call inst$b8vsubu
}
macro svsubu {
call inst$svsubu
}
macro s2vsubu {
call inst$s2vsubu
}
macro s4vsubu {
call inst$s4vsubu
}
macro s8vsubu {
call inst$s8vsubu
}
; </fold>
; <fold exception handler (rax = pointer to exception instance, rcx = pointer to exception instruction)>
macro eenter {
lea rcx, [rcx-$01]
lea rdx, [rbp-.size.loc]
call inst$exceptionenter
}
macro tryblock beginLabel*, endLabel*, nextLabel* {
lea rdx, [beginLabel]
cmp rcx, rdx
jl nextLabel
lea rdx, [endLabel]
cmp rcx, rdx
jge nextLabel
}
macro catchblock classFullName*, catchBlockLabel* {
lea rdx, [classFullName]
call inst$exceptionisclass
test edx, edx
jnz catchBlockLabel
}
macro finallyblock finallyBlockLabel* {
call inst$finallyprepare
call finallyBlockLabel
call inst$finallyrestore
}
macro eleave {
call inst$exceptionleave
.D.END:
}
; </fold>
; </fold>
