ops.tab

OTP是开放电信平台的简称

# ``The contents of this file are subject to the Erlang Public License,
# Version 1.1, (the "License"); you may not use this file except in
# compliance with the License. You should have received a copy of the
# Erlang Public License along with this software. If not, it can be
# retrieved via the world wide web at http://www.erlang.org/.
# 
# Software distributed under the License is distributed on an "AS IS"
# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
# the License for the specific language governing rights and limitations
# under the License.
# 
# The Initial Developer of the Original Code is Ericsson Utvecklings AB.
# Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
# AB. All Rights Reserved.''
# 
#     $Id$
#
#
# The instructions that follows are only known by the loader and the emulator.
# They can be changed without recompiling old Beam files.
#
# Instructions starting with a "i_" prefix are instructions produced by
# instruction transformations; thus, they never occur in BEAM files.
#

# Special instruction used to generate an error message when
# trying to load a module compiled by the V1 compiler (R5 & R6).
# (Specially treated in beam_load.c.)

too_old_compiler/0
too_old_compiler

#
# Obsolete instructions follow.
#

is_list p S => too_old_compiler
is_nonempty_list p R => too_old_compiler
is_nil p R => too_old_compiler

is_tuple p S => too_old_compiler
test_arity p S Arity => too_old_compiler

is_integer p R => too_old_compiler
is_float p R => too_old_compiler
is_atom p R => too_old_compiler

is_eq_exact p S1 S2 => too_old_compiler

#
# All the other instructions.
#

label L
i_func_info I a a I
int_code_end

i_module_info_0
i_module_info_1
i_trace_breakpoint
i_mtrace_breakpoint
i_debug_breakpoint
i_count_breakpoint
i_return_to_trace
i_yield
i_global_cons
i_global_tuple
i_global_copy

return

%macro: allocate Allocate -pack
%macro: allocate_zero AllocateZero -pack
%macro: allocate_heap AllocateHeap -pack
%macro: allocate_heap_zero AllocateHeapZero -pack
%macro: test_heap TestHeap -pack

allocate t t
allocate_heap I I I
deallocate I
init y
allocate_zero t t
allocate_heap_zero I I I

test_heap I I

init2 y y
init3 y y y
init Y1=y | init Y2=y | init Y3=y => init3 Y1 Y2 Y3
init Y1=y | init Y2=y => init2 Y1 Y2
%macro: init2 Init2 -pack
%macro: init3 Init3 -pack

#
# Warning: The put_string instruction is specially treated in the loader.
# Don't change the instruction format unless you change the loader too.
#
put_string I I d

# Selecting values

select_val S=wo Fail=f Size=u Rest=* => const_select_val(S, Fail, Size, Rest)

select_val S=s Fail=f Size=u Rest=* | use_jump_tab(Size, Rest) => \
  gen_jump_tab(S, Fail, Size, Rest)

is_integer Fail=f S | select_val S=s Fail=f Size=u Rest=* | use_jump_tab(Size, Rest) => \
  gen_jump_tab(S, Fail, Size, Rest)

select_val S=s Fail=f Size=u Rest=* | mixed_types(Size, Rest) => \
  gen_split_values(S, Fail, Size, Rest)

is_integer Fail=f S | select_val S=s Fail=f Size=u Rest=* | \
  fixed_size_values(Size, Rest) => gen_select_val(S, Fail, Size, Rest)

is_atom Fail=f S | select_val S=s Fail=f Size=u Rest=* | \
  fixed_size_values(Size, Rest) => gen_select_val(S, Fail, Size, Rest)

select_val S=s Fail=f Size=u Rest=* | fixed_size_values(Size, Rest) => \
  gen_select_val(S, Fail, Size, Rest)

select_val S=s Fail=f Size=u Rest=* | all_values_are_big(Size, Rest) => \
  gen_select_big(S, Fail, Size, Rest)

select_tuple_arity S=s Fail=f Size=u Rest=* => \
  gen_select_tuple_arity(S, Fail, Size, Rest)

i_select_val s f I
i_select_tuple_arity s f I
i_select_big s f
i_select_float s f I

i_jump_on_val_zero s f I
i_jump_on_val s f I I

%macro: get_list GetList -pack
get_list x x x
get_list x x y
get_list x x r
get_list x y x
get_list x y y
get_list x y r
get_list x r x
get_list x r y

get_list y x x
get_list y x y
get_list y x r
get_list y y x
get_list y y y
get_list y y r
get_list y r x
get_list y r y

get_list r x x
get_list r x y
get_list r x r
get_list r y x
get_list r y y
get_list r y r
get_list r r x
get_list r r y

# Old-style catch.
catch y f
catch_end y

# Try/catch.
try Y F => catch Y F
try_case Y => try_end Y
try_end y

try_case_end Big=w => i_put_big Big x | case_end x
try_case_end Float=o => i_put_float Float x | case_end x
try_case_end s

# Destructive set tuple element

set_tuple_element Float=o Tuple Pos => \
   i_put_float Float x | set_tuple_element x Tuple Pos

set_tuple_element Big=w Tuple Pos => i_put_big Big x | set_tuple_element x Tuple Pos

set_tuple_element s d P

# Get tuple element

%macro: i_get_tuple_element GetTupleElement -pack
i_get_tuple_element x P x
i_get_tuple_element r P x
i_get_tuple_element y P x
i_get_tuple_element x P r
i_get_tuple_element y P r

%cold
i_get_tuple_element r P r
i_get_tuple_element x P y
i_get_tuple_element r P y
i_get_tuple_element y P y
%hot

%macro: is_number IsNumber -fail_action
%cold
is_number f r
is_number f x
is_number f y
%cold
is_number Fail=f owi =>
is_number Fail=f na => jump Fail

%macro: is_constant IsConstant -fail_action
%cold
is_constant f x
is_constant f y
is_constant f r
%hot
is_constant Fail=f owia =>
is_constant Fail=f n => jump Fail

jump f

case_end Big=w => i_put_big Big x | case_end x
case_end Float=o => i_put_float Float x | case_end x
badmatch Big=w => i_put_big Big x | badmatch x
badmatch Float=o => i_put_float Float x | badmatch x

case_end s
badmatch s
if_end
raise s s

# Internal now, but could be useful to make known to the compiler.
badarg j
system_limit j

move R R =>
move Float=o Dst=d => i_put_float Float Dst
move Big=w Dst=d => i_put_big Big Dst

move X1=x Y1=y | move X2=x Y2=y => move2 X1 Y1 X2 Y2
move Y1=y X1=x | move Y2=y X2=x => move2 Y1 X1 Y2 X2

%macro: move2 Move2 -pack
move2 x y x y
move2 y x y x

%macro:move Move -pack -gen_dest
move x x
move x y
move x r
move y x
move y r
move r x
move r y
move c x
move c r
move n x
move n r

%cold
move s d
%hot

i_put_float o d
i_put_big w d

# Receive operations.

loop_rec Fail Src | smp_mark_target_label(Fail) => i_loop_rec Fail Src

label L | wait_timeout Fail Src | smp_already_locked(L) => label L | i_wait_timeout_locked Fail Src
wait_timeout Fail Src => i_wait_timeout Fail Src
i_wait_timeout Fail Src=aiow => gen_literal_timeout(Fail, Src)
i_wait_timeout_locked Fail Src=aiow => gen_literal_timeout_locked(Fail, Src)

label L | wait Fail | smp_already_locked(L) => label L | wait_locked Fail
wait Fail | smp() => wait_unlocked Fail

label L | timeout | smp_already_locked(L) => label L | timeout_locked

remove_message
timeout
timeout_locked
i_loop_rec f r
loop_rec_end f
wait f
wait_locked f
wait_unlocked f
i_wait_timeout f I
i_wait_timeout f s
i_wait_timeout_locked f I
i_wait_timeout_locked f s
i_wait_error
i_wait_error_locked


#
# Fetch operations (used for arithmetic instructions).
#

i_fetch S1=w S2=w => i_fetch r r  | i_fetch_big1 S1 | i_fetch_big2 S2
i_fetch S1=w S2   => i_fetch r S2 | i_fetch_big1 S1
i_fetch S1 S2=w   => i_fetch S1 r | i_fetch_big2 S2

i_fetch S1=o S2=o => i_fetch r r  | i_fetch_float1 S1 | i_fetch_float2 S2
i_fetch S1=o S2   => i_fetch r S2 | i_fetch_float1 S1
i_fetch S1 S2=o   => i_fetch S1 r | i_fetch_float2 S2

send

#
# Comparisions.
#

is_eq_exact Lbl=f R=rxy C=c => i_is_eq_const Lbl R C
is_eq Lbl=f R=rxy C=a => i_is_eq_const Lbl R C
is_eq Lbl=f R=rxy C=n => i_is_eq_const Lbl R C

is_ge Lbl S1 S2 => i_fetch S1 S2 | i_is_ge Lbl
is_lt Lbl S1 S2 => i_fetch S1 S2 | i_is_lt Lbl
is_eq Lbl S1 S2 => i_fetch S1 S2 | i_is_eq Lbl
is_ne Lbl S1 S2 => i_fetch S1 S2 | i_is_ne Lbl

is_eq_exact Lbl=f S1 S2 => i_fetch S1 S2 | i_is_eq_exact Lbl
is_ne_exact Lbl S1 S2 => i_fetch S1 S2 | i_is_ne_exact Lbl

i_is_lt f
i_is_ge f
i_is_eq f
i_is_ne f
i_is_eq_exact f
i_is_ne_exact f

%macro: i_is_eq_const Equal -fail_action
i_is_eq_const f r c
i_is_eq_const f x c
i_is_eq_const f y c

#
# Putting things.
#

put_tuple u==0 Dst => i_put_tuple_only u Dst
put_tuple Arity Dst | put V=o => i_put_tuple_only Arity Dst | i_put_float V x | put x
put_tuple Arity Dst | put V=w => i_put_tuple_only Arity Dst | i_put_big V x | put x
put_tuple Arity Dst | put V => i_put_tuple Arity V Dst

i_put_tuple_only A d

%macro: i_put_tuple PutTuple -pack
i_put_tuple A x x
i_put_tuple A y x
i_put_tuple A r x
i_put_tuple A n x
i_put_tuple A c x
i_put_tuple A x y
i_put_tuple A x r
i_put_tuple A y r
i_put_tuple A n r
i_put_tuple A c r

%cold
i_put_tuple A r y
i_put_tuple A r r
i_put_tuple A y y
i_put_tuple A c y
%hot

put_list S1=w S2=w Dst => i_put_big S1 x | i_put_big S2 Dst | put_list x Dst Dst
put_list S1=w S2 Dst => i_put_big S1 x | put_list x S2 Dst
put_list S1 S2=w Dst => i_put_big S2 x | put_list S1 x Dst

put_list S1=o S2=o Dst => i_put_float S1 x | i_put_float S2 Dst | put_list x Dst Dst
put_list S1=o S2 Dst => i_put_float S1 x | put_list x S2 Dst
put_list S1 S2=o Dst => i_put_float S2 x | put_list S1 x Dst

%macro:put_list PutList -pack -gen_dest

put_list x n x
put_list y n x
put_list x x x
put_list y x x
put_list c x x
put_list c n x
put_list c x r
put_list x x r
put_list y r r
put_list c n r

put_list y y x
put_list x y x
put_list r x x
put_list r y x
put_list r x r
put_list y y r
put_list c y x
put_list y r x
put_list r n x
put_list c r x

%cold
put_list x n r
put_list x r r
put_list r n r
put_list s s d
%hot

put S=o => i_put_float S x | put x
put S=w => i_put_big S x | put x
%macro: put Put
put x
put r
put y
put c
put n

%macro: i_fetch FetchArgs -pack