ops.tab

OTP是开放电信平台的简称

#

move S=c r | call_ext Ar=u Func=u$is_not_bif => i_move_call_ext S r Func
move S=c r | call_ext_last Ar=u Func=u$is_not_bif D => i_move_call_ext_last Func D S r
move S=c r | call_ext_only Ar=u Func=u$is_not_bif => i_move_call_ext_only Func S r 

call_ext Ar=u Func        => i_call_ext Func
call_ext_last Ar=u Func D => i_call_ext_last Func D
call_ext_only Ar=u Func   => i_call_ext_only Func

i_apply
i_apply_last P
i_apply_only

i_apply_fun
i_apply_fun_last P
i_apply_fun_only

i_hibernate

call_bif0 e
call_bif1 e
call_bif2 e
call_bif3 e

#
# Calls to non-building and guard BIFs.
#

bif0 u$bif:erlang:self/0 Dst=d => self Dst
bif0 u$bif:erlang:node/0 Dst=d => node Dst

bif1 Fail Bif=u$bif:erlang:get/1 Src=s Dst=d => i_get Src Dst

bif2 Jump=j u$bif:erlang:element/2 S1=ow S2=ow Dst=d => badarg Jump
bif2 Jump=j u$bif:erlang:element/2 S1=ow S2=s Dst=d => badarg Jump
bif2 Jump=j u$bif:erlang:element/2 S1=s S2=ow Dst=d => badarg Jump
bif2 Jump=j u$bif:erlang:element/2 S1=s S2=s Dst=d => gen_element(Jump, S1, S2, Dst)

bif1 Fail Bif S1=o Dst => i_put_float S1 x | bif1 Fail Bif x Dst
bif1 Fail Bif S1=w Dst => i_put_big S1 x | bif1 Fail Bif x Dst
bif1 p Bif S1 Dst => bif1_body Bif S1 Dst

bif2 p Bif S1 S2 Dst => i_fetch S1 S2 | i_bif2_body Bif Dst
bif2 Fail=f Bif S1 S2 Dst => i_fetch S1 S2 | i_bif2 Fail Bif Dst

i_get s d

%macro: self Self
self r
self x
self y

%macro: node Node
node r
node x
%cold
node y
%hot

i_fast_element j I s d
i_element j s s d

bif1 f b s d
bif1_body b s d
i_bif2 f b d
i_bif2_body b d

#
# Internal calls.
#

move S=c r | call Ar P=f => i_move_call S r P
move S=s r | call Ar P=f => move_call S r P

i_move_call c r f

%macro:move_call MoveCall -arg_f -size -nonext
move_call/3

move_call x r f
move_call y r f

move S=c r | call_last Ar P=f D => i_move_call_last P D S r
move S r | call_last Ar P=f D => move_call_last S r P D

i_move_call_last f P c r

%macro:move_call_last MoveCallLast -arg_f -nonext

move_call_last/4
move_call_last x r f P
move_call_last y r f P

move S=c r | call_only Ar P=f => i_move_call_only P S r
move S=x r | call_only Ar P=f => move_call_only S r P

i_move_call_only f c r

%macro:move_call_only MoveCallOnly -arg_f -nonext
move_call_only/3

move_call_only x r f

call Ar Func        => i_call Func
call_last Ar Func D => i_call_last Func D
call_only Ar Func   => i_call_only Func

i_call f
i_call_last f P
i_call_only f

i_call_ext e
i_call_ext_last e P
i_call_ext_only e

i_move_call_ext c r e
i_move_call_ext_last e P c r
i_move_call_ext_only e c r

# Fun calls.

call_fun Arity=u | deallocate D | return => i_call_fun_last Arity D
call_fun Arity=u => i_call_fun Arity

i_call_fun I
i_call_fun_last I P

make_fun2 OldIndex=u => gen_make_fun2(OldIndex)

%macro: i_make_fun MakeFun -pack
%cold
i_make_fun I t
%hot

%macro: is_function IsFunction -fail_action
is_function f x
is_function f y
is_function f r
is_function Fail=f cwo => jump Fail

func_info M=a a==am_module_info A=u==0 | label L | move n r => gen_func_info_mi(M, A, L)
func_info M=a a==am_module_info A=u==1 | label L | move n r => gen_func_info_mi(M, A, L)
func_info M=a F=a A=u | label L => gen_func_info(M, F, A, L)

# ================================================================
# New bit syntax matching (R11B).
# ================================================================

%cold
%macro: bs_start_match2 BsStartMatch2 -fail_action -gen_dest
bs_start_match2 f r I I d
bs_start_match2 f x I I d
bs_start_match2 f y I I d
bs_start_match2 Fail=f icwoa X Y D => jump Fail

bs_save2 r I
bs_save2 x I
bs_restore2 r I
bs_restore2 x I

# Fetching integers from binaries.
bs_get_integer2 Fail=f Ms=rx Live=u Sz=s Unit=u Flags=u Dst=d => \
			gen_get_integer2(Fail, Ms, Live, Sz, Unit, Flags, Dst)
bs_get_integer2 Fail=f Ms=rx Live=u Sz=w Unit=u Flags=u Dst=d => \
			gen_get_integer2(Fail, Ms, Live, Sz, Unit, Flags, Dst)
%macro: i_bs_get_integer_imm2 BsGetIntegerImm2 -fail_action -gen_dest
%macro: i_bs_get_integer2 BsGetInteger2 -fail_action -gen_dest
%macro: i_bs_get_integer2_8 BsGetInteger2_8 -fail_action -gen_dest
%macro: i_bs_get_integer2_16 BsGetInteger2_16 -fail_action -gen_dest
i_bs_get_integer_imm2 f r I I I d
i_bs_get_integer_imm2 f x I I I d
i_bs_get_integer2 f r I s I d
i_bs_get_integer2 f x I s I d
i_bs_get_integer2_8 f r d
i_bs_get_integer2_8 f x d
i_bs_get_integer2_16 f r d
i_bs_get_integer2_16 f x d

# Fetching binaries from binaries.
bs_get_binary2 Fail=f Ms=rx Live=u Sz=s Unit=u Flags=u Dst=d => \
			gen_get_binary2(Fail, Ms, Live, Sz, Unit, Flags, Dst)
bs_get_binary2 Fail=f Ms=rx Live=u Sz=w Unit=u Flags=u Dst=d => \
			gen_get_binary2(Fail, Ms, Live, Sz, Unit, Flags, Dst)
%macro: i_bs_get_binary_imm2 BsGetBinaryImm_2 -fail_action -gen_dest
%macro: i_bs_get_binary2 BsGetBinary_2 -fail_action -gen_dest
%macro: i_bs_get_binary_all2 BsGetBinaryAll_2 -fail_action -gen_dest
i_bs_get_binary_imm2 f r I I I d
i_bs_get_binary_imm2 f x I I I d
i_bs_get_binary2 f r I s I d
i_bs_get_binary2 f x I s I d
i_bs_get_binary_all2 f r I I d
i_bs_get_binary_all2 f x I I d

# Fetching float from binaries.
bs_get_float2 Fail=f Ms=rx Live=u Sz=s Unit=u Flags=u Dst=d => \
		gen_get_float2(Fail, Ms, Live, Sz, Unit, Flags, Dst)

bs_get_float2 Fail=f Ms=rx Live=u Sz=w Unit=u Flags=u Dst=d => jump Fail

%macro: i_bs_get_float2 BsGetFloat2 -fail_action -gen_dest
i_bs_get_float2 f r I s I d
i_bs_get_float2 f x I s I d

# Miscellanous

bs_skip_bits2 Fail=f Ms=rx Sz=s Unit=u Flags=u => \
			gen_skip_bits2(Fail, Ms, Sz, Unit, Flags)
bs_skip_bits2 Fail=f Ms=rx Sz=w Unit=u Flags=u => \
			gen_skip_bits2(Fail, Ms, Sz, Unit, Flags)

%macro: i_bs_skip_bits_imm2 BsSkipBitsImm2 -fail_action
i_bs_skip_bits_imm2 f r I
i_bs_skip_bits_imm2 f x I

%macro: i_bs_skip_bits2 BsSkipBits2 -fail_action
i_bs_skip_bits2 f r x I
i_bs_skip_bits2 f r r I
i_bs_skip_bits2 f r y I
i_bs_skip_bits2 f x x I
i_bs_skip_bits2 f x r I
i_bs_skip_bits2 f x y I

%macro: i_bs_skip_bits_all2 BsSkipBitsAll2 -fail_action
i_bs_skip_bits_all2 f r I
i_bs_skip_bits_all2 f x I 

bs_test_tail2 Fail=f Ms=rx Bits=u==0 => bs_test_zero_tail2 Fail Ms
bs_test_tail2 Fail=f Ms=rx Bits=u => bs_test_tail_imm2 Fail Ms Bits
bs_test_zero_tail2 f r
bs_test_zero_tail2 f x
bs_test_tail_imm2 f r I
bs_test_tail_imm2 f x I


%hot

#
# Constructing binaries
#
%cold

bs_init2 Fail Sz Words Regs Flags Dst | binary_too_big(Sz) => system_limit Fail

bs_init2 Fail Sz=u Words=u==0 Regs Flags Dst | should_gen_heap_bin(Sz) | new_bs_instructions() => i_bs_init_heap_bin Sz Regs Dst
bs_init2 Fail Sz=u Words=u==0 Regs Flags Dst | new_bs_instructions() => i_bs_init Sz Regs Dst

bs_init2 Fail Sz=u Words Regs Flags Dst | should_gen_heap_bin(Sz) | new_bs_instructions() => i_bs_init_heap_bin_heap Sz Words Regs Dst
bs_init2 Fail Sz=u Words Regs Flags Dst | new_bs_instructions() => \
   i_bs_init_heap Sz Words Regs Dst


bs_init2 Fail Sz Words=u==0 Regs Flags Dst | new_bs_instructions() => \
  i_bs_init_fail Sz Fail Regs Dst
bs_init2 Fail Sz Words Regs Flags Dst | new_bs_instructions() => \
  i_fetch Sz r | i_bs_init_fail_heap Words Fail Regs Dst

i_bs_init_fail r j I d
i_bs_init_fail x j I d
i_bs_init_fail y j I d

i_bs_init_fail_heap I j I d

i_bs_init I I d
i_bs_init_heap_bin I I d

i_bs_init_heap I I I d
i_bs_init_heap_bin_heap I I I d

bs_bits_to_bytes Fail Src Dst => i_bs_bits_to_bytes Src Fail Dst

i_bs_bits_to_bytes r j d
i_bs_bits_to_bytes x j d
i_bs_bits_to_bytes y j d

bs_bits_to_bytes2 Src Dst => i_bs_bits_to_bytes2 Src Dst

i_bs_bits_to_bytes2 r d
i_bs_bits_to_bytes2 x d
i_bs_bits_to_bytes2 y d

bs_final2 Src Dst => i_bs_final2 Src Dst

i_bs_final2 r d
i_bs_final2 x d
i_bs_final2 y d

bs_add Fail S1=i==0 S2 Unit=u==1 D => move S2 D
bs_add Fail S1 S2 Unit D => i_fetch S1 S2 | i_bs_add Fail Unit D

i_bs_add j I d

#
# Storing integers into binaries.
#

bs_put_integer Fail=j Sz=s Unit=u Flags=u Big=w => \
	i_put_big Big x | bs_put_integer Fail Sz Unit Flags x
bs_put_integer Fail=j Sz=s Unit=u Flags=u Bad=o => badarg Fail
bs_put_integer Fail=j Sz=s Unit=u Flags=u Src=s => \
			gen_put_integer(Fail, Sz, Unit, Flags, Src)
bs_put_integer Fail=j Sz=w Unit=u Flags=u Src=s => \
			gen_put_integer(Fail, Sz, Unit, Flags, Src)

%macro: i_new_bs_put_integer NewBsPutInteger
%macro: i_new_bs_put_integer_imm NewBsPutIntegerImm

i_new_bs_put_integer j s I s
i_new_bs_put_integer_imm j I I s

#
# Storing floats into binaries.
#
bs_put_float Fail Sz=w Unit Flags Val => badarg Fail

bs_put_float Fail=j Sz Unit=u Flags=u Big=w => \
	i_put_big Big x | bs_put_float Fail Sz Unit Flags x

bs_put_float Fail=j Sz Unit=u Flags=u Float=o => \
	i_put_float Float x | bs_put_float Fail Sz Unit Flags x

bs_put_float Fail=j Sz=s Unit=u Flags=u Src=s => \
			gen_put_float(Fail, Sz, Unit, Flags, Src)

%macro: i_new_bs_put_float NewBsPutFloat
%macro: i_new_bs_put_float_imm NewBsPutFloatImm

i_new_bs_put_float j s I s
i_new_bs_put_float_imm j I I s

#
# Storing binaries into binaries.
#

bs_put_binary Fail=j Sz=s Unit=u Flags=u Bad=ow => badarg Fail
bs_put_binary Fail=j Sz=s Unit=u Flags=u Src=s => \
			gen_put_binary(Fail, Sz, Unit, Flags, Src)
bs_put_binary Fail=j Sz=w Unit=u Flags=u Src=s => \
			gen_put_binary(Fail, Sz, Unit, Flags, Src)

%macro: i_new_bs_put_binary NewBsPutBinary
i_new_bs_put_binary j s I s

%macro: i_new_bs_put_binary_imm NewBsPutBinaryImm
i_new_bs_put_binary_imm j I s

%macro: i_new_bs_put_binary_all NewBsPutBinaryAll
i_new_bs_put_binary_all j s

#
# Warning: The i_bs_put_string and i_new_bs_put_string instructions
# are specially treated in the loader.
# Don't change the instruction format unless you change the loader too.
#

bs_put_string Len String | query_new_instructions() => i_new_bs_put_string Len String

i_new_bs_put_string I I

%hot

#
# New floating point instructions (R8).
#

fadd p FR1 FR2 FR3 => i_fadd FR1 FR2 FR3
fsub p FR1 FR2 FR3 => i_fsub FR1 FR2 FR3
fmul p FR1 FR2 FR3 => i_fmul FR1 FR2 FR3
fdiv p FR1 FR2 FR3 => i_fdiv FR1 FR2 FR3
fnegate p FR1 FR2 => i_fnegate FR1 FR2

fconv Int=i Dst=l => move Int x | fconv x Dst
fconv Float=o Dst=l => i_put_float Float x | fmove x Dst
fconv Big=w Dst=l => i_put_big Big x | fconv x Dst

fmove o l
fmove d l
fconv d l

i_fadd l l l
i_fsub l l l
i_fmul l l l
i_fdiv l l l
i_fnegate l l

fclearerror | no_fpe_signals() =>
fcheckerror p | no_fpe_signals() =>
fcheckerror p => i_fcheckerror

i_fcheckerror
fclearerror

fmove FR=l Dst=d | new_float_allocation() => fmove_new FR Dst

# The new instruction for moving a float out of a floating point register.
# (No allocation.)
fmove_new l d

#
# New apply instructions in R10B.
#

apply I
apply_last I P

#
# New instruction in R11B-4.
#

put_literal Lit=u Dest=d => gen_put_literal(Lit, Dest)

i_put_literal/3
i_put_literal I I d