%% -*- erlang-indent-level: 2 -*- %% %% Licensed under the Apache License, Version 2.0 (the "License"); %% you may not use this file except in compliance with the License. %% You may obtain a copy of the License at %% %% http://www.apache.org/licenses/LICENSE-2.0 %% %% Unless required by applicable law or agreed to in writing, software %% distributed under the License is distributed on an "AS IS" BASIS, %% WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. %% See the License for the specific language governing permissions and %% limitations under the License. %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% HiPE Intermediate Code %% ==================================================================== %% Filename : hipe_icode.erl %% Module : hipe_icode %% Purpose : Provide primops for the Icode data structure. %% History : 1997-? Erik Johansson (happi@it.uu.se): Created. %% 2001-01-30 EJ (happi@it.uu.se): %% Apply, primop, guardop removed %% 2003-03-15 ES (happi@acm.org): %% Started commenting in Edoc. %% Moved pretty printer to separate file. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%@doc %% This module implements "Linear Icode" and Icode instructions. %% %% <p> Icode is a simple (in that it has few instructions) imperative %% language, used as the first Intermediate Code in the HiPE compiler. %% Icode is closely related to Erlang, and Icode instructions operate %% on Erlang terms. </p> %% %% <h2><a href="#type-icode">Icode</a></h2> %% %% <p> Linear Icode for a function consists of: %% <ul> %% <li> the function's name (`{M,F,A}'), </li> %% <li> a list of parameters, </li> %% <li> a list of instructions, </li> %% <li> data, </li> %% <li> information about whether the function is a leaf function, </li> %% <li> information about whether the function is a closure, and </li> %% <li> the range for labels and variables in the code. </li> %% </ul> %% </p> %% %% <h2><a href="#type-icode_instruction">Icode Instructions</a> (and %% their components)</h2> %% %% Control flow: %% <dl> %% <dt><code><a href="#type-if">'if'</a> %% {Cond::<a href="#type-cond">cond()</a>, %% Args::[<a href="#type-arg">arg()</a>], %% TrueLabel::<a href="#type-label_name">label_name()</a>, %% FalseLabel::<a href="#type-label_name">label_name()</a> %% } :: %% <a href="#type-icode_instruction">icode_instr()</a></code></dt> %% <dd> %% The if instruction compares the arguments (Args) with %% condition (Cond) and jumps to either TrueLabel or %% FalseLabel. (At the moment...) There are only binary %% conditions so the number of arguments should be two. %% <p> %% An if instructions ends a basic block and should be followed %% by a label (or be the last instruction of the code). %% </p></dd> %% %% <dt><code><a href="#type-switch_val">switch_val</a> %% {Term::<a href="#type-arg">var()</a>, %% FailLabel::<a href="#type-label_name">label_name()</a>, %% Length::integer(), %% Cases::[{<a href="#type-symbol">symbol()</a>,<a %% href="#type-label_name">label_name()</a>}] %% }:: %% <a href="#type-icode_instruction">icode_instr()</a></code></dt> %% <dd> %% The switch_val instruction compares the argument Term to the %% symbols in the lists Cases, control is transfered to the label %% that corresponds to the first symbol that matches. If no %% symbol matches control is transfered to FailLabel. (NOTE: The %% length argument is not currently in use.) %% <p> %% The switch_val instruction can be assumed to be implemented as %% efficiently as possible given the symbols in the case %% list. (Jump-table, bianry-serach, or nested ifs) %% </p><p> %% A switch_val instructions ends a basic block and should be %% followed by a label (or be the last instruction of the code). %% </p></dd> %% %% <dt><code><a href="#type-switch_tuple_arity">switch_tuple_arity</a> %% {Term::<a href="#type-arg">var()</a>, %% FailLabel::<a href="#type-label_name">label_name()</a>, %% Length::integer(), %% Cases::[{integer(),<a href="#type-label_name">label_name()</a>}] %% }:: %% <a href="#type-icode_instruction">icode_instr()</a></code></dt> %% <dd> %% The switch_tuple_arity instruction compares the size of the %% tuple in the argument Term to the integers in the lists Cases, %% control is transfered to the label that corresponds to the %% first integer that matches. If no integer matches control is %% transfered to FailLabel. (NOTE: The length argument is not %% currently in use.) %% <p> %% The switch_tuple_arity instruction can be assumed to be %% implemented as efficently as possible given the symbols in the %% case list. (Jump-table, bianry-serach, or nested ifs) %% </p><p> %% A switch_tuple_arity instructions ends a basic block and %% should be followed by a label (or be the last instruction of %% the code). %% </p></dd> %% %% <dt>`type {typ_expr, arg, true_label, false_label}}'</dt> %% <dt>`goto {label}'</dt> %% <dt>`label {name}'</dt> %% </dl> %% %% Moves: %% <dl> %% <dt>`move {dst, src}'</dt> %% <dt>`phi {dst, arglist}'</dt> %% </dl> %% %% Function application: %% <dl> %% <dt>`call {[dst], fun, [arg], type, continuation, fail, %% in_guard}'</dt> %% <dd> %% Where `type' is one of {`local', `remote', `primop'} %% and `in_guard' is either `true' or `false'.</dd> %% <dt>`enter {fun, [arg], type}'</dt> %% <dd> %% Where `type' is one of {`local', `remote', `primop'} %% and `in_guard' is either `true' or `false'.</dd> %% <dt>`return {[var]}'</dt> %% <dd> %% <strong>WARNING:</strong> Multiple return values are yet not %% fully implemented and tested. %% </dd> %% </dl> %% %% Error handling: %% <dl> %% <dt>`begin_try {label, successor}'</dt> %% <dt>`end_try'</dt> %% <dt>`begin_handler {dstlist}'</dt> %% <dt>`fail {Args, Class}'</dt> %% <dd>Where `Class' is one of %% {`exit', `throw', `error', `rethrow'}. For `error/2', `[args]' %% is `[Reason,Trace]'. For `rethrow', `Args' is %% `[Exception,Reason]' - this only occurs in autogenerated code. %% </dd> %% </dl> %% %% Comments: %% <dl> %% <dt>`comment{Text::string()}'</dt> %% </dl> %% %% <h4>Notes</h4> %% %% <p> A constant can only show up on the RHS of a `move' instruction %% and in `if' and `switch_*'</p> %% <p> %% Classification of primops should be like this: %% <ul> %% <li> `erlang:exit/1, erlang:throw/1, erlang:error/1, %% erlang:error/2, erlang:fault/1', %% and `erlang:fault/2' should use the %% {@link fail(). fail-instruction} in Icode.</li> %% <li> Calls or tail-recursive calls to BIFs, operators, or internal %% functions should be implemented with `call' or `enter' %% respectively, with the primop flag set.</li> %% <li> All other Erlang functions should be implemented with `call' %% or `enter' respectively, without the primop flag set.</li> %% </ul> %% </p> %% %% <h4>Primops</h4> %% %% <pre> %% Constructors: %% cons - [Car, Cdr] %% mktuple - [Element1, Element2, ..., ElementN] %% call_fun - [BoundArg1, ..., BoundArgN, Fun] %% enter_fun - [BoundArg1, ..., BoundArgN, Fun] %% #mkfun{} - [FreeVar1, FreeVar2, ..., FreeVarN] %% %% Binaries: %% bs_init %% {bs_put_string, Bytes, Size} %% bs_final %% %% Selectors: %% element - [Index, Tuple] %% unsafe_hd - [List] %% unsafe_tl - [List] %% #unsafe_element{} - [Tuple] %% #unsafe_update_element{} - [Tuple, Val] %% #closure_element{} - [Fun] %% %% Arithmetic: [Arg1, Arg2] %% '+', '-', '*', '/', 'div', 'rem', %% 'band', 'bor', 'bxor', 'bnot', 'bsl', 'bsr' %% %% Receive: %% check_get_msg - [] %% next_msg - [] %% select_msg - [] %% set_timeout - [Timeout] %% clear_timeout - [] %% suspend_msg - [] %% %% </pre> %% %% <h4>Guardops: (primops that can be used in guards and can fail)</h4> %% <pre> %% Selectors: %% unsafe_hd - [List] %% unsafe_tl - [List] %% #element{} - [Index, Tuple] %% #unsafe_element{} - [Tuple] %% %% Arithmetic: [Arg1, Arg2] %% '+', '-', '*', '/', 'div', 'rem', %% 'band', 'bor', 'bxor', 'bnot', 'bsl', 'bsr', %% fix_add, fix_sub %% Do these exist? %% %% Concurrency: %% {erlang,self,0} - [] %% </pre> %% %% %% <h4>Relational Operations (Cond in if instruction)</h4> %% <pre> %% gt, lt, geq, leq, %% eqeq, neq, exact_eqeq, exact_neq %% </pre> %% %% <h4>Type tests</h4> %% <pre> %% list %% nil %% cons %% tuple %% {tuple, N} %% atom %% {atom, Atom} %% number %% integer %% {integer, N} %% fixnum %% bignum %% float %% pid %% port %% {record, Atom, Size} %% reference %% binary %% function %% </pre> %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %%===================================================================== -module(hipe_icode). -include("../main/hipe.hrl"). -include("hipe_icode.hrl"). %% @type icode(Fun, Params, IsClosure, IsLeaf, Code, Data, VarRange,LabelRange) %% Fun = mfa() %% Params = [var()] %% IsClosure = boolean() %% IsLeaf = boolean() %% Code = [icode_instr()] %% Data = data() %% VarRange = {integer(),integer()} %% LabelRange = {integer(),integer()} %% %% @type icode_instr(I) %% I = if() | switch_val() | switch_tuple_arity() | type() | goto() %% | label() | move() | phi() | call() | enter() | return() %% | begin_try() | end_try() | begin_handler() | fail() | comment() %% %% @type if(Cond, Args, TrueLabel, FalseLabel) %% Cond = cond() %% Args = [arg()] %% TrueLabel = label_name() %% FalseLabel = label_name() %% %% @type switch_val(Term, FailLabel, Length, Cases) %% Term = var() %% FailLabel = label_name() %% Length = integer() %% Cases = [{symbol(),label_name()}] %% %% @type switch_tuple_arity(Arg, FailLabel, Length, Cases) %% Term = var() %% FailLabel = label_name() %% Length = integer() %% Cases = [{symbol(),label_name()}] %% %% @type type(TypeTest, Arg, True_label, False_label) %% TypeTest = type_test() %% Args = [arg()] %% TrueLabel = label_name() %% FalseLabel = label_name() %% %% @type goto(Label) Label = label_name() %% %% @type label(Name) Name = label_name() %% %% @type move(Dst, Src) Dst = var() Src = arg() %% %% @type phi(Dst, Id, Arglist) %% Dst = var() | fvar() %% Id = var() | fvar() %% Arglist = [{Pred, Src}] %% Pred = label_name() %% Src = var() | fvar() %% %% @type call(Dst, Fun, Arg, Type, Continuation, FailLabel, InGuard) %% Dst = [var()] %% Fun = mfa() | primop() | closure() %% Arg = [var()] %% Type = call_type() %% Continuation = [] | label_name() %% FailLabel = [] | label_name() %% InGuard = boolean() %% %% @type enter(Fun, Arg, Type) %% Fun = mfa() | primop() | closure() %% Arg = [var()] %% Type = call_type() %% %% @type return (Vars) Vars = [var()] %% %% @type begin_try(FailLabel, Successor) %% FailLabel = label_name() %% Successor = label_name() %% %% @type end_try() %% %% @type begin_handler(Dst) %% Dst = [var()] %% %% @type fail(Class, Args, Label) %% Class = exit_class() %% Args = [var()] %% Label = label_name() %% %% @type comment(Text) Text = string() %% @type call_type() = 'local' | 'remote' | 'primop' %% @type exit_class() = 'exit' | 'throw' | 'error' | 'rethrow' %% @type cond() = gt | lt | geq | leq | eqeq | neq | exact_eqeq | exact_neq %% @type type_test() = %% list %% | nil %% | cons %% | tuple %% | {tuple, integer()} %% | atom %% | {atom, atom()} %% | number %% | integer %% | {integer, integer()} %% | fixnum %% | bignum %% | float %% | pid %% | port %% | {record, atom(), integer()} %% | reference %% | binary %% | function %% %% @type mfa(Mod,Fun,Arity) = {atom(),atom(),arity()} %% @type arg() = var() | const() %% @type farg() = fvar() | float() %% @type var(Name) Name = integer() %% @type fvar(Name) Name = integer() %% @type label_name(Name) Name = integer() %% @type symbol(S) = atom() | number() %% @type const(C) C = immediate() %% @type immediate(I) = I %% I = term() %% @end %% ____________________________________________________________________ %% %% Exports %% -export([mk_icode/7, %% mk_icode(Fun, Params, IsClosure, IsLeaf, %% Code, VarRange, LabelRange) mk_icode/8, %% mk_icode(Fun, Params, IsClosure, IsLeaf, %% Code, Data, VarRange, LabelRange) icode_fun/1, icode_params/1, icode_params_update/2, icode_is_closure/1, icode_closure_arity/1, icode_closure_arity_update/2, icode_is_leaf/1, icode_code/1, icode_code_update/2, icode_data/1, %% icode_data_update/2, icode_var_range/1, icode_label_range/1, icode_info/1, icode_info_update/2]). -export([mk_if/4, %% mk_if(Op, Args, TrueLbl, FalseLbl) %% mk_if/5, %% mk_if(Op, Args, TrueLbl, FalseLbl, Prob) if_op/1, if_op_update/2, if_true_label/1, if_false_label/1, if_args/1, if_args_update/2, if_pred/1, %% is_if/1, mk_switch_val/4, %% mk_switch_val/5, switch_val_term/1, switch_val_fail_label/1, %% switch_val_length/1, switch_val_cases/1, switch_val_cases_update/2, %% is_switch_val/1, mk_switch_tuple_arity/4, %% mk_switch_tuple_arityl/5, switch_tuple_arity_term/1, switch_tuple_arity_fail_label/1, switch_tuple_arity_fail_label_update/2, %% switch_tuple_arity_length/1, switch_tuple_arity_cases/1, switch_tuple_arity_cases_update/2, %% is_switch_tuple_arity/1, mk_type/4, %% mk_type(Args, Type, TrueLbl, FalseLbl) mk_type/5, %% mk_type(Args, Type, TrueLbl, FalseLbl, P) type_args/1, %% type_args_update/2, type_test/1, type_true_label/1, type_false_label/1, type_pred/1, is_type/1, mk_guardop/5, %% mk_guardop(Dst, Fun, Args, Continuation, Fail) mk_primop/3, %% mk_primop(Dst, Fun, Args) mk_primop/5, %% mk_primop(Dst, Fun, Args, Cont, Fail) mk_call/5, %% mk_call(Dst, Mod, Fun, Args, Type) %% mk_call/7, %% mk_call(Dst, Mod, Fun, Args, Type, %% Continuation, Fail) mk_call/8, %% mk_call(Dst, Mod, Fun, Args, Type, %% Continuation, Fail, Guard) call_dstlist/1, call_dstlist_update/2, %% call_dst_type/1, call_args/1, call_args_update/2, call_fun/1, call_fun_update/2, call_type/1, call_continuation/1, call_fail_label/1, call_set_fail_label/2, call_set_continuation/2, is_call/1, call_in_guard/1, mk_goto/1, %% mk_goto(Lbl) goto_label/1, mk_enter/4, %% mk_enter(Mod, Fun, Args, Type) mk_enter_primop/2, %% mk_enter_primop(Op, Type) enter_fun/1, enter_fun_update/2, enter_args/1, enter_args_update/2, enter_type/1, is_enter/1, mk_return/1, %% mk_return(Vars) %% mk_fail/1, %% mk_fail(Args) class = exit mk_fail/2, %% mk_fail(Args, Class) %% mk_fail/3, %% mk_fail(Args, Class, Label) mk_move/2, %% mk_move(Dst, Src) %% mk_moves/2, %% mk_moves(DstList, SrcList) mk_begin_try/2, %% mk_begin_try(Label, Successor) mk_begin_handler/1, %% mk_begin_handler(ReasonDst) mk_end_try/0, %% mk_end_try() %% mk_elements/2, %% mk_elements(Tuple, Vars) mk_label/1, %% mk_label(Name) mk_new_label/0, %% mk_new_label() mk_comment/1, %% mk_comment(Text) mk_const/1, %% mk_const(Const) mk_var/1, %% mk_var(Id) annotate_variable/2, %% annotate_var_or_reg(VarOrReg, Type) unannotate_variable/1,%% unannotate_var_or_reg(VarOrReg) mk_reg/1, %% mk_reg(Id) mk_reg_gcsafe/1, %% mk_reg_gcsafe(Id) mk_fvar/1, %% mk_fvar(Id) mk_new_var/0, %% mk_new_var() mk_new_fvar/0, %% mk_new_fvar() mk_new_reg/0, %% mk_new_reg() mk_new_reg_gcsafe/0, %% mk_new_reg_gcsafe() mk_phi/1, %% mk_phi(Id) mk_phi/2 %% mk_phi(Id, ArgList) ]). %% %% Identifiers %% -export([%% is_fail/1, is_return/1, is_move/1, %% is_begin_try/1, %% is_begin_handler/1, %% is_end_try/1, is_goto/1, is_label/1, is_comment/1, is_const/1, is_var/1, is_fvar/1, is_reg/1, is_variable/1, is_annotated_variable/1, %% is_uncond/1, is_phi/1]). %% %% Selectors %% -export([phi_dst/1, phi_id/1, %% phi_args/1, phi_arg/2, phi_arglist/1, phi_enter_pred/3, phi_remove_pred/2, phi_redirect_pred/3, move_dst/1, move_src/1, move_src_update/2, begin_try_label/1, begin_try_successor/1, begin_handler_dstlist/1, label_name/1, comment_text/1, return_vars/1, fail_args/1, fail_class/1, fail_label/1, fail_set_label/2, var_name/1, variable_annotation/1, fvar_name/1, reg_name/1, reg_is_gcsafe/1, const_value/1 ]). %% %% Misc %% -export([args/1, uses/1, defines/1, is_safe/1, reduce_unused/1, strip_comments/1, subst/2, subst_uses/2, subst_defines/2, redirect_jmp/3, successors/1, fails_to/1, is_branch/1 ]). -export([highest_var/1, highest_label/1]). %% %% Exported types %% -export_type([icode/0, params/0]). -type params() :: [icode_var()]. %%--------------------------------------------------------------------- %% %% Icode %% %%--------------------------------------------------------------------- -spec mk_icode(mfa(), params(), boolean(), boolean(), [icode_instr()], {non_neg_integer(),non_neg_integer()}, {icode_lbl(),icode_lbl()}) -> icode(). mk_icode(Fun, Params, IsClosure, IsLeaf, Code, VarRange, LabelRange) -> #icode{'fun'=Fun, params=Params, code=Code, is_closure=IsClosure, is_leaf=IsLeaf, data=hipe_consttab:new(), var_range=VarRange, label_range=LabelRange}. -spec mk_icode(mfa(), params(), boolean(), boolean(), [icode_instr()], hipe_consttab(), {non_neg_integer(),non_neg_integer()}, {icode_lbl(),icode_lbl()}) -> icode(). mk_icode(Fun, Params, IsClosure, IsLeaf, Code, Data, VarRange, LabelRange) -> #icode{'fun'=Fun, params=Params, code=Code, data=Data, is_closure=IsClosure, is_leaf=IsLeaf, var_range=VarRange, label_range=LabelRange}. -spec icode_fun(icode()) -> mfa(). icode_fun(#icode{'fun' = MFA}) -> MFA. -spec icode_params(icode()) -> params(). icode_params(#icode{params = Params}) -> Params. -spec icode_params_update(icode(), params()) -> icode(). icode_params_update(Icode, Params) -> Icode#icode{params = Params}. -spec icode_is_closure(icode()) -> boolean(). icode_is_closure(#icode{is_closure = Closure}) -> Closure. -spec icode_is_leaf(icode()) -> boolean(). icode_is_leaf(#icode{is_leaf = Leaf}) -> Leaf. -spec icode_code(icode()) -> icode_instrs(). icode_code(#icode{code = Code}) -> Code. -spec icode_code_update(icode(), icode_instrs()) -> icode(). icode_code_update(Icode, NewCode) -> Vmax = highest_var(NewCode), Lmax = highest_label(NewCode), Icode#icode{code = NewCode, var_range = {0,Vmax}, label_range = {0,Lmax}}. -spec icode_data(icode()) -> hipe_consttab(). icode_data(#icode{data=Data}) -> Data. %% %% -spec icode_data_update(icode(), hipe_consttab()) -> icode(). %% icode_data_update(Icode, NewData) -> Icode#icode{data=NewData}. -spec icode_var_range(icode()) -> {non_neg_integer(), non_neg_integer()}. icode_var_range(#icode{var_range = VarRange}) -> VarRange. -spec icode_label_range(icode()) -> {non_neg_integer(), non_neg_integer()}. icode_label_range(#icode{label_range = LabelRange}) -> LabelRange. -spec icode_info(icode()) -> icode_info(). icode_info(#icode{info = Info}) -> Info. -spec icode_info_update(icode(), icode_info()) -> icode(). icode_info_update(Icode, Info) -> Icode#icode{info = Info}. -spec icode_closure_arity(icode()) -> arity(). icode_closure_arity(#icode{closure_arity = Arity}) -> Arity. -spec icode_closure_arity_update(icode(), arity()) -> icode(). icode_closure_arity_update(Icode, Arity) -> Icode#icode{closure_arity = Arity}. %%---------------------------------------------------------------------------- %% Instructions %%---------------------------------------------------------------------------- %%---- %% if %%---- -spec mk_if(icode_if_op(), [icode_term_arg()], icode_lbl(), icode_lbl()) -> #icode_if{}. mk_if(Op, Args, TrueLbl, FalseLbl) -> #icode_if{op=Op, args=Args, true_label=TrueLbl, false_label=FalseLbl, p=0.5}. %% mk_if(Op, Args, TrueLbl, FalseLbl, P) -> %% #icode_if{op=Op, args=Args, true_label=TrueLbl, false_label=FalseLbl, p=P}. -spec if_op(#icode_if{}) -> icode_if_op(). if_op(#icode_if{op=Op}) -> Op. -spec if_op_update(#icode_if{}, icode_if_op()) -> #icode_if{}. if_op_update(IF, NewOp) -> IF#icode_if{op=NewOp}. -spec if_args(#icode_if{}) -> [icode_term_arg()]. if_args(#icode_if{args=Args}) -> Args. -spec if_args_update(#icode_if{}, [icode_term_arg()]) -> #icode_if{}. if_args_update(IF, Args) -> IF#icode_if{args=Args}. -spec if_true_label(#icode_if{}) -> icode_lbl(). if_true_label(#icode_if{true_label=TrueLbl}) -> TrueLbl. -spec if_true_label_update(#icode_if{}, icode_lbl()) -> #icode_if{}. if_true_label_update(IF, TrueLbl) -> IF#icode_if{true_label=TrueLbl}. -spec if_false_label(#icode_if{}) -> icode_lbl(). if_false_label(#icode_if{false_label=FalseLbl}) -> FalseLbl. -spec if_false_label_update(#icode_if{}, icode_lbl()) -> #icode_if{}. if_false_label_update(IF, FalseLbl) -> IF#icode_if{false_label=FalseLbl}. -spec if_pred(#icode_if{}) -> float(). if_pred(#icode_if{p=P}) -> P. %%------------ %% switch_val %%------------ -spec mk_switch_val(icode_var(), icode_lbl(), non_neg_integer(), [icode_switch_case()]) -> #icode_switch_val{}. mk_switch_val(Term = #icode_variable{kind='var'}, FailLbl, Length, Cases) -> #icode_switch_val{term=Term, fail_label=FailLbl, length=Length, cases=Cases}. -spec switch_val_term(#icode_switch_val{}) -> icode_var(). switch_val_term(#icode_switch_val{term=Term}) -> Term. -spec switch_val_fail_label(#icode_switch_val{}) -> icode_lbl(). switch_val_fail_label(#icode_switch_val{fail_label=FailLbl}) -> FailLbl. -spec switch_val_fail_label_update(#icode_switch_val{}, icode_lbl()) -> #icode_switch_val{}. switch_val_fail_label_update(SV, FailLbl) -> SV#icode_switch_val{fail_label=FailLbl}. %% switch_val_length(#icode_switch_val{length=Length}) -> Length. -spec switch_val_cases(#icode_switch_val{}) -> [icode_switch_case()]. switch_val_cases(#icode_switch_val{cases=Cases}) -> Cases. -spec switch_val_cases_update(#icode_switch_val{}, [icode_switch_case()]) -> #icode_switch_val{}. switch_val_cases_update(SV, NewCases) -> SV#icode_switch_val{cases = NewCases}. %%-------------------- %% switch_tuple_arity %%-------------------- -spec mk_switch_tuple_arity(icode_var(), icode_lbl(), non_neg_integer(), [icode_switch_case()]) -> #icode_switch_tuple_arity{}. mk_switch_tuple_arity(Term = #icode_variable{kind='var'}, FailLbl, Length, Cases) -> #icode_switch_tuple_arity{term=Term, fail_label=FailLbl, length=Length, cases=Cases}. -spec switch_tuple_arity_term(#icode_switch_tuple_arity{}) -> icode_var(). switch_tuple_arity_term(#icode_switch_tuple_arity{term=Term}) -> Term. -spec switch_tuple_arity_fail_label(#icode_switch_tuple_arity{}) -> icode_lbl(). switch_tuple_arity_fail_label(#icode_switch_tuple_arity{fail_label=FailLbl}) -> FailLbl. -spec switch_tuple_arity_fail_label_update(#icode_switch_tuple_arity{}, icode_lbl()) -> #icode_switch_tuple_arity{}. switch_tuple_arity_fail_label_update(S, FailLbl) -> S#icode_switch_tuple_arity{fail_label=FailLbl}. %% switch_tuple_arity_length(#icode_switch_tuple_arity{length=Length}) -> Length. -spec switch_tuple_arity_cases(#icode_switch_tuple_arity{}) -> [icode_switch_case()]. switch_tuple_arity_cases(#icode_switch_tuple_arity{cases=Cases}) -> Cases. -spec switch_tuple_arity_cases_update(#icode_switch_tuple_arity{}, [icode_switch_case()]) -> #icode_switch_tuple_arity{}. switch_tuple_arity_cases_update(Cond, NewCases) -> Cond#icode_switch_tuple_arity{cases = NewCases}. %%------ %% type %%------ -spec mk_type([icode_term_arg()], icode_type_test(), icode_lbl(), icode_lbl()) -> #icode_type{}. mk_type(Args, Test, TrueLbl, FalseLbl) -> mk_type(Args, Test, TrueLbl, FalseLbl, 0.5). -spec mk_type([icode_term_arg()], icode_type_test(), icode_lbl(), icode_lbl(), float()) -> #icode_type{}. mk_type(Args, Test, TrueLbl, FalseLbl, P) -> #icode_type{test=Test, args=Args, true_label=TrueLbl, false_label=FalseLbl, p=P}. -spec type_test(#icode_type{}) -> icode_type_test(). type_test(#icode_type{test=Test}) -> Test. -spec type_args(#icode_type{}) -> [icode_term_arg()]. type_args(#icode_type{args=Args}) -> Args. %% type_args_update(T, Args) -> T#icode_type{args=Args}. -spec type_true_label(#icode_type{}) -> icode_lbl(). type_true_label(#icode_type{true_label=TrueLbl}) -> TrueLbl. -spec type_false_label(#icode_type{}) -> icode_lbl(). type_false_label(#icode_type{false_label=FalseLbl}) -> FalseLbl. -spec type_pred(#icode_type{}) -> float(). type_pred(#icode_type{p=P}) -> P. -spec is_type(icode_instr()) -> boolean(). is_type(#icode_type{}) -> true; is_type(_) -> false. %%------ %% goto %%------ -spec mk_goto(icode_lbl()) -> #icode_goto{}. mk_goto(Lbl) -> #icode_goto{label=Lbl}. -spec goto_label(#icode_goto{}) -> icode_lbl(). goto_label(#icode_goto{label=Lbl}) -> Lbl. -spec is_goto(icode_instr()) -> boolean(). is_goto(#icode_goto{}) -> true; is_goto(_) -> false. %%-------- %% return %%-------- -spec mk_return([icode_var()]) -> #icode_return{}. mk_return(Vars) -> #icode_return{vars=Vars}. -spec return_vars(#icode_return{}) -> [icode_var()]. return_vars(#icode_return{vars=Vars}) -> Vars. -spec is_return(icode_instr()) -> boolean(). is_return(#icode_return{}) -> true; is_return(_) -> false. %%------ %% fail %%------ %% mk_fail(Args) when is_list(Args) -> mk_fail(Args, error). -spec mk_fail([icode_term_arg()], icode_exit_class()) -> #icode_fail{}. mk_fail(Args, Class) when is_list(Args) -> case Class of error -> ok; exit -> ok; rethrow -> ok; throw -> ok end, #icode_fail{class=Class, args=Args}. %% mk_fail(Args, Class, Label) when is_list(Args) -> %% #icode_fail{class=Class, args=Args, fail_label=Label}. -spec fail_class(#icode_fail{}) -> icode_exit_class(). fail_class(#icode_fail{class=Class}) -> Class. -spec fail_args(#icode_fail{}) -> [icode_term_arg()]. fail_args(#icode_fail{args=Args}) -> Args. -spec fail_label(#icode_fail{}) -> [] | icode_lbl(). fail_label(#icode_fail{fail_label=Label}) -> Label. -spec fail_set_label(#icode_fail{}, [] | icode_lbl()) -> #icode_fail{}. fail_set_label(I=#icode_fail{}, Label) -> I#icode_fail{fail_label = Label}. %%------ %% move %%------ -spec mk_move(#icode_variable{}, #icode_variable{} | #icode_const{}) -> #icode_move{}. mk_move(Dst, Src) -> case Src of #icode_variable{} -> ok; #icode_const{} -> ok end, #icode_move{dst=Dst, src=Src}. -spec move_dst(#icode_move{}) -> #icode_variable{}. move_dst(#icode_move{dst=Dst}) -> Dst. -spec move_src(#icode_move{}) -> #icode_variable{} | #icode_const{}. move_src(#icode_move{src=Src}) -> Src. -spec move_src_update(#icode_move{}, #icode_variable{} | #icode_const{}) -> #icode_move{}. move_src_update(M, NewSrc) -> M#icode_move{src=NewSrc}. -spec is_move(icode_instr()) -> boolean(). is_move(#icode_move{}) -> true; is_move(_) -> false. %%----- %% phi %%----- %% The id field is not entirely redundant. It is used in mappings %% in the SSA pass since the dst field can change. -spec mk_phi(#icode_variable{}) -> #icode_phi{}. mk_phi(Var) -> #icode_phi{dst=Var, id=Var, arglist=[]}. -spec mk_phi(#icode_variable{}, [{icode_lbl(), #icode_variable{}}]) -> #icode_phi{}. mk_phi(Var, ArgList) -> #icode_phi{dst=Var, id=Var, arglist=ArgList}. -spec phi_dst(#icode_phi{}) -> #icode_variable{}. phi_dst(#icode_phi{dst=Dst}) -> Dst. -spec phi_id(#icode_phi{}) -> #icode_variable{}. phi_id(#icode_phi{id=Id}) -> Id. -spec phi_arglist(#icode_phi{}) -> [{icode_lbl(), #icode_variable{}}]. phi_arglist(#icode_phi{arglist=ArgList}) -> ArgList. -spec phi_args(#icode_phi{}) -> [#icode_variable{}]. phi_args(P) -> [Var || {_, Var} <- phi_arglist(P)]. -spec phi_arg(#icode_phi{}, icode_lbl()) -> #icode_variable{}. phi_arg(P, Pred) -> case lists:keyfind(Pred, 1, phi_arglist(P)) of {_, Var} -> Var; false -> exit({'No such predecessor to phi', {Pred, P}}) end. -spec is_phi(icode_instr()) -> boolean(). is_phi(#icode_phi{}) -> true; is_phi(_) -> false. -spec phi_enter_pred(#icode_phi{}, icode_lbl(), #icode_variable{}) -> #icode_phi{}. phi_enter_pred(Phi, Pred, Var) -> NewArg = {Pred, Var}, Phi#icode_phi{arglist=[NewArg|lists:keydelete(Pred, 1, phi_arglist(Phi))]}. -spec phi_remove_pred(#icode_phi{}, icode_lbl()) -> #icode_move{} | #icode_phi{}. phi_remove_pred(Phi, Pred) -> NewArgList = lists:keydelete(Pred, 1, phi_arglist(Phi)), case NewArgList of [Arg] -> %% the Phi should be turned into an appropriate move instruction {_Label, Var = #icode_variable{}} = Arg, mk_move(phi_dst(Phi), Var); [_|_] -> Phi#icode_phi{arglist=NewArgList} end. phi_argvar_subst(P, Subst) -> NewArgList = [{Pred, subst1(Subst, Var)} || {Pred,Var} <- phi_arglist(P)], P#icode_phi{arglist=NewArgList}. -spec phi_redirect_pred(#icode_phi{}, icode_lbl(), icode_lbl()) -> #icode_phi{}. phi_redirect_pred(P, OldPred, NewPred) -> Subst = [{OldPred, NewPred}], NewArgList = [{subst1(Subst, Pred), Var} || {Pred,Var} <- phi_arglist(P)], P#icode_phi{arglist=NewArgList}. %% %% primop and guardop %% %% Whether a function is a "primop" - i.e., an internal thing - or not, %% is really only shown by its name. An {M,F,A} always represents a %% function in some Erlang module (although it might be a BIF, and %% could possibly be inline expanded). It is convenient to let the %% constructor functions check the name and set the type automatically, %% especially for guardops - some guardops are primitives and some are %% MFA:s, and this way we won't have to rewrite all calls to mk_guardop %% to flag whether they are primops or not. -spec mk_primop([#icode_variable{}], icode_funcall(), [icode_argument()]) -> #icode_call{}. mk_primop(DstList, Fun, ArgList) -> mk_primop(DstList, Fun, ArgList, [], []). -spec mk_primop([#icode_variable{}], icode_funcall(), [icode_argument()], [] | icode_lbl(), [] | icode_lbl()) -> #icode_call{}. mk_primop(DstList, Fun, ArgList, Continuation, Fail) -> Type = op_type(Fun), make_call(DstList, Fun, ArgList, Type, Continuation, Fail, false). %% Note that a 'guardop' is just a call that occurred in a guard. In %% this case, we should always have continuation labels True and False. -spec mk_guardop([#icode_variable{}], icode_funcall(), [icode_argument()], icode_lbl(), icode_lbl()) -> #icode_call{}. mk_guardop(DstList, Fun, ArgList, True, False) -> Type = op_type(Fun), make_call(DstList, Fun, ArgList, Type, True, False, true). op_type(Fun) -> case is_mfa(Fun) of true -> remote; false -> primop end. is_mfa({M,F,A}) when is_atom(M), is_atom(F), is_integer(A), 0 =< A, A =< 255 -> true; is_mfa(_) -> false. %%------ %% call %%------ -spec mk_call([#icode_variable{}], atom(), atom(), [icode_argument()], 'local' | 'remote') -> #icode_call{}. mk_call(DstList, M, F, ArgList, Type) -> mk_call(DstList, M, F, ArgList, Type, [], [], false). %% mk_call(DstList, M, F, ArgList, Type, Continuation, Fail) -> %% mk_call(DstList, M, F, ArgList, Type, Continuation, Fail, false). -spec mk_call([#icode_variable{}], atom(), atom(), [icode_argument()], 'local' | 'remote', [] | icode_lbl(), [] | icode_lbl(), boolean()) -> #icode_call{}. mk_call(DstList, M, F, ArgList, Type, Continuation, Fail, InGuard) when is_atom(M), is_atom(F) -> case Type of local -> ok; remote -> ok end, Fun = {M,F,length(ArgList)}, make_call(DstList, Fun, ArgList, Type, Continuation, Fail, InGuard). %% The common constructor for all calls (for internal use only) %% %% Note: If the "guard" flag is `true', it means that if the call fails, %% we can simply jump to the Fail label (if it exists) without %% generating any additional exception information - it isn't needed. -spec make_call([#icode_variable{}], icode_funcall(), [icode_argument()], icode_call_type(), [] | icode_lbl(), [] | icode_lbl(), boolean()) -> #icode_call{}. make_call(DstList, Fun, ArgList, Type, Continuation, Fail, InGuard) -> #icode_call{dstlist=DstList, 'fun'=Fun, args=ArgList, type=Type, continuation=Continuation, fail_label=Fail, in_guard=InGuard}. -spec call_dstlist(#icode_call{}) -> [#icode_variable{}]. call_dstlist(#icode_call{dstlist=DstList}) -> DstList. -spec call_dstlist_update(#icode_call{}, [#icode_variable{}]) -> #icode_call{}. call_dstlist_update(C, Dest) -> C#icode_call{dstlist=Dest}. -spec call_type(#icode_call{}) -> icode_call_type(). call_type(#icode_call{type=Type}) -> Type. %% -spec call_dst_type(#icode_call{}) -> erl_type(). %% call_dst_type(#icode_call{dst_type=DstType}) -> DstType. -spec call_args(#icode_call{}) -> [icode_argument()]. call_args(#icode_call{args=Args}) -> Args. -spec call_args_update(#icode_call{}, [icode_argument()]) -> #icode_call{}. call_args_update(C, Args) -> C#icode_call{args=Args}. -spec call_fun(#icode_call{}) -> icode_funcall(). call_fun(#icode_call{'fun'=Fun}) -> Fun. %% Note that updating the name field requires recomputing the call type, %% in case it changes from a remote/local call to a primop call. -spec call_fun_update(#icode_call{}, icode_funcall()) -> #icode_call{}. call_fun_update(C, Fun) -> Type = case is_mfa(Fun) of true -> call_type(C); false -> primop end, C#icode_call{'fun'=Fun, type=Type}. -spec call_continuation(#icode_call{}) -> [] | icode_lbl(). call_continuation(#icode_call{continuation=Continuation}) -> Continuation. -spec call_fail_label(#icode_call{}) -> [] | icode_lbl(). call_fail_label(#icode_call{fail_label=Fail}) -> Fail. -spec call_set_continuation(#icode_call{}, [] | icode_lbl()) -> #icode_call{}. call_set_continuation(I, Continuation) -> I#icode_call{continuation = Continuation}. -spec call_set_fail_label(#icode_call{}, [] | icode_lbl()) -> #icode_call{}. call_set_fail_label(I=#icode_call{}, Fail) -> case Fail of [] -> I#icode_call{fail_label=Fail, in_guard=false}; _ -> I#icode_call{fail_label=Fail} end. -spec is_call(icode_instr()) -> boolean(). is_call(#icode_call{}) -> true; is_call(_) -> false. -spec call_in_guard(#icode_call{}) -> boolean(). call_in_guard(#icode_call{in_guard=InGuard}) -> InGuard. %%------- %% enter %%------- -spec mk_enter(atom(), atom(), [icode_term_arg()], 'local' | 'remote') -> #icode_enter{}. mk_enter(M, F, Args, Type) when is_atom(M), is_atom(F) -> case Type of local -> ok; remote -> ok end, #icode_enter{'fun'={M,F,length(Args)}, args=Args, type=Type}. -spec enter_fun(#icode_enter{}) -> icode_funcall(). enter_fun(#icode_enter{'fun'=Fun}) -> Fun. -spec enter_fun_update(#icode_enter{}, icode_funcall()) -> #icode_enter{}. enter_fun_update(E, Fun) -> Type = case is_mfa(Fun) of true -> enter_type(E); false -> primop end, E#icode_enter{'fun'=Fun, type=Type}. -spec enter_args(#icode_enter{}) -> [icode_term_arg()]. enter_args(#icode_enter{args=Args}) -> Args. -spec enter_args_update(#icode_enter{}, [icode_term_arg()]) -> #icode_enter{}. enter_args_update(E, Args) -> E#icode_enter{args=Args}. -spec enter_type(#icode_enter{}) -> icode_call_type(). enter_type(#icode_enter{type=Type}) -> Type. -spec is_enter(icode_instr()) -> boolean(). is_enter(#icode_enter{}) -> true; is_enter(_) -> false. -spec mk_enter_primop(icode_primop(), [icode_term_arg()]) -> #icode_enter{type::'primop'}. mk_enter_primop(Op, Args) -> #icode_enter{'fun'=Op, args=Args, type=primop}. %%----------- %% begin_try %%----------- %% The reason that begin_try is a branch instruction is just so that it %% keeps the fail-to block linked into the CFG, until the exception %% handling instructions are eliminated. -spec mk_begin_try(icode_lbl(), icode_lbl()) -> #icode_begin_try{}. mk_begin_try(Label, Successor) -> #icode_begin_try{label=Label, successor=Successor}. -spec begin_try_label(#icode_begin_try{}) -> icode_lbl(). begin_try_label(#icode_begin_try{label=Label}) -> Label. -spec begin_try_successor(#icode_begin_try{}) -> icode_lbl(). begin_try_successor(#icode_begin_try{successor=Successor}) -> Successor. %%--------- %% end_try %%--------- -spec mk_end_try() -> #icode_end_try{}. mk_end_try() -> #icode_end_try{}. %%--------------- %% begin_handler %%--------------- -spec mk_begin_handler([icode_var()]) -> #icode_begin_handler{}. mk_begin_handler(Dstlist) -> #icode_begin_handler{dstlist=Dstlist}. -spec begin_handler_dstlist(#icode_begin_handler{}) -> [icode_var()]. begin_handler_dstlist(#icode_begin_handler{dstlist=Dstlist}) -> Dstlist. %% -spec is_begin_handler(icode_instr()) -> boolean(). %% is_begin_handler(#icode_begin_handler{}) -> true; %% is_begin_handler(_) -> false. %%------- %% label %%------- -spec mk_label(icode_lbl()) -> #icode_label{}. mk_label(Name) when is_integer(Name), Name >= 0 -> #icode_label{name=Name}. -spec label_name(#icode_label{}) -> icode_lbl(). label_name(#icode_label{name=Name}) -> Name. -spec is_label(icode_instr()) -> boolean(). is_label(#icode_label{}) -> true; is_label(_) -> false. %%--------- %% comment %%--------- -spec mk_comment(icode_comment_text()) -> #icode_comment{}. %% @doc If `Txt' is a list of characters (possibly deep), it will be %% printed as a string; otherwise, `Txt' will be printed as a term. mk_comment(Txt) -> #icode_comment{text=Txt}. -spec comment_text(#icode_comment{}) -> icode_comment_text(). comment_text(#icode_comment{text=Txt}) -> Txt. -spec is_comment(icode_instr()) -> boolean(). is_comment(#icode_comment{}) -> true; is_comment(_) -> false. %%--------------------------------------------------------------------- %% Arguments (variables and constants) %%--------------------------------------------------------------------- %%------- %% const %%------- -spec mk_const(simple_const() | structured_const() | binary()) -> #icode_const{}. mk_const(C) -> #icode_const{value=#flat{value=C}}. -spec const_value(#icode_const{}) -> simple_const() | structured_const() | binary(). const_value(#icode_const{value=#flat{value=X}}) -> X. -spec is_const(icode_argument()) -> boolean(). is_const(#icode_const{}) -> true; is_const(_) -> false. %%----- %% var %%----- -spec mk_var(non_neg_integer()) -> #icode_variable{kind::'var'}. mk_var(V) -> #icode_variable{name=V, kind=var}. -spec var_name(#icode_variable{kind::'var'}) -> non_neg_integer(). var_name(#icode_variable{name=Name, kind=var}) -> Name. -spec is_var(icode_argument()) -> boolean(). is_var(#icode_variable{kind=var}) -> true; is_var(_) -> false. -spec mk_reg(non_neg_integer()) -> #icode_variable{kind::'reg'}. mk_reg(V) -> #icode_variable{name=V, kind=reg}. -spec mk_reg_gcsafe(non_neg_integer()) -> #icode_variable{kind::'reg_gcsafe'}. mk_reg_gcsafe(V) -> #icode_variable{name=V, kind=reg_gcsafe}. -spec reg_name(#icode_variable{kind::'reg'|'reg_gcsafe'}) -> non_neg_integer(). reg_name(#icode_variable{name=Name, kind=reg}) -> Name; reg_name(#icode_variable{name=Name, kind=reg_gcsafe}) -> Name. -spec reg_is_gcsafe(#icode_variable{kind::'reg'}) -> 'false'; (#icode_variable{kind::'reg_gcsafe'}) -> 'true'. reg_is_gcsafe(#icode_variable{kind=reg}) -> false; reg_is_gcsafe(#icode_variable{kind=reg_gcsafe}) -> true. -spec is_reg(icode_argument()) -> boolean(). is_reg(#icode_variable{kind=reg}) -> true; is_reg(#icode_variable{kind=reg_gcsafe}) -> true; is_reg(_) -> false. -spec mk_fvar(non_neg_integer()) -> #icode_variable{kind::'fvar'}. mk_fvar(V) -> #icode_variable{name=V, kind=fvar}. -spec fvar_name(#icode_variable{kind::'fvar'}) -> non_neg_integer(). fvar_name(#icode_variable{name=Name, kind=fvar}) -> Name. -spec is_fvar(icode_argument()) -> boolean(). is_fvar(#icode_variable{kind=fvar}) -> true; is_fvar(_) -> false. -spec is_variable(icode_argument()) -> boolean(). is_variable(#icode_variable{}) -> true; is_variable(_) -> false. -spec annotate_variable(#icode_variable{}, variable_annotation()) -> #icode_variable{}. annotate_variable(X, Anno) -> X#icode_variable{annotation = Anno}. -spec is_annotated_variable(icode_argument()) -> boolean(). is_annotated_variable(#icode_variable{annotation=[]}) -> false; is_annotated_variable(#icode_variable{}) -> true; is_annotated_variable(_) -> false. -spec unannotate_variable(#icode_variable{}) -> #icode_variable{}. unannotate_variable(X) -> X#icode_variable{annotation=[]}. -spec variable_annotation(#icode_variable{}) -> variable_annotation(). variable_annotation(#icode_variable{annotation=Anno}) -> Anno. %% %% Floating point Icode instructions. %% %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% %% Liveness info %% -spec uses(icode_instr()) -> [#icode_variable{}]. uses(Instr) -> remove_constants(args(Instr)). -spec args(icode_instr()) -> [icode_argument()]. args(I) -> case I of #icode_if{} -> if_args(I); #icode_switch_val{} -> [switch_val_term(I)]; #icode_switch_tuple_arity{} -> [switch_tuple_arity_term(I)]; #icode_type{} -> type_args(I); #icode_move{} -> [move_src(I)]; #icode_fail{} -> fail_args(I); #icode_call{} -> call_args(I); #icode_enter{} -> enter_args(I); #icode_return{} -> return_vars(I); #icode_phi{} -> phi_args(I); #icode_goto{} -> []; #icode_begin_try{} -> []; #icode_begin_handler{} -> []; #icode_end_try{} -> []; #icode_comment{} -> []; #icode_label{} -> [] end. -spec defines(icode_instr()) -> [#icode_variable{}]. defines(I) -> case I of #icode_move{} -> remove_constants([move_dst(I)]); #icode_call{} -> remove_constants(call_dstlist(I)); #icode_begin_handler{} -> remove_constants(begin_handler_dstlist(I)); #icode_phi{} -> remove_constants([phi_dst(I)]); #icode_if{} -> []; #icode_switch_val{} -> []; #icode_switch_tuple_arity{} -> []; #icode_type{} -> []; #icode_goto{} -> []; #icode_fail{} -> []; #icode_enter{} -> []; #icode_return{} -> []; #icode_begin_try{} -> []; #icode_end_try{} -> []; #icode_comment{} -> []; #icode_label{} -> [] end. -spec remove_constants([icode_argument()]) -> [#icode_variable{}]. remove_constants(L) -> [V || V <- L, (not is_const(V))]. %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% %% %% Utilities %% %% %% Substitution: replace occurrences of X by Y if {X,Y} is in the %% Subst_list. -spec subst([{_,_}], I) -> I when I :: icode_instr(). subst(Subst, I) -> subst_defines(Subst, subst_uses(Subst, I)). -spec subst_uses([{_,_}], I) -> I when I :: icode_instr(). subst_uses(Subst, I) -> case I of #icode_if{} -> I#icode_if{args = subst_list(Subst, if_args(I))}; #icode_switch_val{} -> I#icode_switch_val{term = subst1(Subst, switch_val_term(I))}; #icode_switch_tuple_arity{} -> I#icode_switch_tuple_arity{term = subst1(Subst, switch_tuple_arity_term(I))}; #icode_type{} -> I#icode_type{args = subst_list(Subst, type_args(I))}; #icode_move{} -> I#icode_move{src = subst1(Subst, move_src(I))}; #icode_fail{} -> I#icode_fail{args = subst_list(Subst, fail_args(I))}; #icode_call{} -> I#icode_call{args = subst_list(Subst, call_args(I))}; #icode_enter{} -> I#icode_enter{args = subst_list(Subst, enter_args(I))}; #icode_return{} -> I#icode_return{vars = subst_list(Subst, return_vars(I))}; #icode_phi{} -> phi_argvar_subst(I, Subst); #icode_goto{} -> I; #icode_begin_try{} -> I; #icode_begin_handler{} -> I; #icode_end_try{} -> I; #icode_comment{} -> I; #icode_label{} -> I end. -spec subst_defines([{_,_}], I) -> I when I :: icode_instr(). subst_defines(Subst, I) -> case I of #icode_move{} -> I#icode_move{dst = subst1(Subst, move_dst(I))}; #icode_call{} -> I#icode_call{dstlist = subst_list(Subst, call_dstlist(I))}; #icode_begin_handler{} -> I#icode_begin_handler{dstlist = subst_list(Subst, begin_handler_dstlist(I))}; #icode_phi{} -> I#icode_phi{dst = subst1(Subst, phi_dst(I))}; #icode_if{} -> I; #icode_switch_val{} -> I; #icode_switch_tuple_arity{} -> I; #icode_type{} -> I; #icode_goto{} -> I; #icode_fail{} -> I; #icode_enter{} -> I; #icode_return{} -> I; #icode_begin_try{} -> I; #icode_end_try{} -> I; #icode_comment{} -> I; #icode_label{} -> I end. subst_list(S, Is) -> [subst1(S, I) || I <- Is]. subst1([], I) -> I; subst1([{I,Y}|_], I) -> Y; subst1([_|Pairs], I) -> subst1(Pairs, I). %% %% @doc Returns the successors of an Icode instruction. %% In CFG form only branch instructions have successors, %% but in linear form other instructions like e.g. moves %% might be the last instruction of some basic block. %% -spec successors(icode_instr()) -> [icode_lbl()]. successors(I) -> case I of #icode_if{} -> [if_true_label(I), if_false_label(I)]; #icode_goto{} -> [goto_label(I)]; #icode_switch_val{} -> CaseLabels = [L || {_,L} <- switch_val_cases(I)], [switch_val_fail_label(I) | CaseLabels]; #icode_switch_tuple_arity{} -> CaseLabels = [L || {_,L} <- switch_tuple_arity_cases(I)], [switch_tuple_arity_fail_label(I) | CaseLabels]; #icode_type{} -> [type_true_label(I), type_false_label(I)]; #icode_call{} -> case call_continuation(I) of [] -> []; L when is_integer(L) -> [L] end ++ case call_fail_label(I) of [] -> []; L when is_integer(L) -> [L] end; #icode_begin_try{} -> [begin_try_successor(I), begin_try_label(I)]; #icode_fail{} -> case fail_label(I) of [] -> []; L when is_integer(L) -> [L] end; #icode_enter{} -> []; #icode_return{} -> []; #icode_comment{} -> []; %% the following are included here for handling linear code #icode_move{} -> []; #icode_begin_handler{} -> [] end. %% %% @doc Returns the fail labels of an Icode instruction. %% -spec fails_to(icode_instr()) -> [icode_lbl()]. fails_to(I) -> case I of #icode_switch_val{} -> [switch_val_fail_label(I)]; #icode_switch_tuple_arity{} -> [switch_tuple_arity_fail_label(I)]; #icode_call{} -> case call_fail_label(I) of [] -> []; L when is_integer(L) -> [L] end; #icode_begin_try{} -> [begin_try_label(I)]; % just for safety #icode_fail{} -> case fail_label(I) of [] -> []; L when is_integer(L) -> [L] end; #icode_if{} -> []; % XXX: Correct? #icode_enter{} -> []; % XXX: Correct? #icode_goto{} -> []; #icode_type{} -> []; % XXX: Correct? #icode_return{} -> [] end. %% %% @doc Redirects jumps from label Old to label New. %% If the instruction does not jump to Old, it remains unchanged. %% The New label can be the special [] label used for calls with %% fall-throughs. %% -spec redirect_jmp(icode_instr(), icode_lbl(), [] | icode_lbl()) -> icode_instr(). redirect_jmp(Jmp, ToOld, ToOld) -> Jmp; % no need to do anything redirect_jmp(Jmp, ToOld, ToNew) -> NewI = case Jmp of #icode_if{} -> NewJmp = case if_true_label(Jmp) of ToOld -> if_true_label_update(Jmp, ToNew); _ -> Jmp end, case if_false_label(NewJmp) of ToOld -> if_false_label_update(NewJmp, ToNew); _ -> NewJmp end; #icode_goto{} -> case goto_label(Jmp) of ToOld -> Jmp#icode_goto{label=ToNew}; _ -> Jmp end; #icode_switch_val{} -> NewJmp = case switch_val_fail_label(Jmp) of ToOld -> switch_val_fail_label_update(Jmp, ToNew); _ -> Jmp end, Cases = [case Pair of {Val,ToOld} -> {Val,ToNew}; Unchanged -> Unchanged end || Pair <- switch_val_cases(NewJmp)], NewJmp#icode_switch_val{cases = Cases}; #icode_switch_tuple_arity{} -> NewJmp = case switch_tuple_arity_fail_label(Jmp) of ToOld -> Jmp#icode_switch_tuple_arity{fail_label=ToNew}; _ -> Jmp end, Cases = [case Pair of {Val,ToOld} -> {Val,ToNew}; Unchanged -> Unchanged end || Pair <- switch_tuple_arity_cases(NewJmp)], NewJmp#icode_switch_tuple_arity{cases = Cases}; #icode_type{} -> NewJmp = case type_true_label(Jmp) of ToOld -> Jmp#icode_type{true_label=ToNew}; _ -> Jmp end, case type_false_label(NewJmp) of ToOld -> NewJmp#icode_type{false_label=ToNew}; _ -> NewJmp end; #icode_call{} -> NewCont = case call_continuation(Jmp) of ToOld -> ToNew; OldCont -> OldCont end, NewFail = case call_fail_label(Jmp) of ToOld -> ToNew; OldFail -> OldFail end, Jmp#icode_call{continuation = NewCont, fail_label = NewFail}; #icode_begin_try{} -> NewLabl = case begin_try_label(Jmp) of ToOld -> ToNew; OldLab -> OldLab end, NewSucc = case begin_try_successor(Jmp) of ToOld -> ToNew; OldSucc -> OldSucc end, Jmp#icode_begin_try{label=NewLabl, successor=NewSucc}; #icode_fail{} -> case fail_label(Jmp) of ToOld -> Jmp#icode_fail{fail_label=ToNew}; _ -> Jmp end end, %% Turn a branch into a goto if it has only one successor and it is %% safe to do so. case ordsets:from_list(successors(NewI)) of [Label] -> Goto = mk_goto(Label), case NewI of #icode_if{} -> Goto; #icode_switch_tuple_arity{} -> Goto; #icode_switch_val{} -> Goto; #icode_type{} -> Goto; _ -> NewI end; _ -> NewI end. %% %% Is this an unconditional jump (causes a basic block not to have a %% fallthrough successor). %% %% is_uncond(I) -> %% case I of %% #icode_goto{} -> true; %% #icode_fail{} -> true; %% #icode_enter{} -> true; %% #icode_return{} -> true; %% #icode_call{} -> %% case call_fail_label(I) of %% [] -> %% case call_continuation(I) of %% [] -> false; %% _ -> true %% end; %% _ -> true %% end; %% _ -> false %% end. %% @spec is_branch(icode_instr()) -> boolean() %% %% @doc Succeeds if the Icode instruction is a branch. I.e. a %% (possibly conditional) discontinuation of linear control flow. %% @end -spec is_branch(icode_instr()) -> boolean(). is_branch(Instr) -> case Instr of #icode_if{} -> true; #icode_switch_val{} -> true; #icode_switch_tuple_arity{} -> true; #icode_type{} -> true; #icode_goto{} -> true; #icode_fail{} -> true; #icode_call{} -> case call_fail_label(Instr) of [] -> call_continuation(Instr) =/= []; _ -> true end; #icode_enter{} -> true; #icode_return{} -> true; #icode_begin_try{} -> true; %% false cases below #icode_move{} -> false; #icode_begin_handler{} -> false; #icode_end_try{} -> false; #icode_comment{} -> false; #icode_label{} -> false; #icode_phi{} -> false end. %% %% @doc Makes a new variable. %% -spec mk_new_var() -> icode_var(). mk_new_var() -> mk_var(hipe_gensym:get_next_var(icode)). %% %% @doc Makes a new fp variable. %% -spec mk_new_fvar() -> icode_fvar(). mk_new_fvar() -> mk_fvar(hipe_gensym:get_next_var(icode)). %% %% @doc Makes a new register. %% -spec mk_new_reg() -> icode_reg(). mk_new_reg() -> mk_reg(hipe_gensym:get_next_var(icode)). %% %% @doc Makes a new gcsafe register; that is, a register that is allowed to be %% live over calls and other operations that might cause GCs and thus move heap %% data around. %% -spec mk_new_reg_gcsafe() -> icode_reg(). mk_new_reg_gcsafe() -> mk_reg_gcsafe(hipe_gensym:get_next_var(icode)). %% %% @doc Makes a new label. %% -spec mk_new_label() -> #icode_label{}. mk_new_label() -> mk_label(hipe_gensym:get_next_label(icode)). %% %% %% %% @doc Makes a bunch of move operations. %% %% %% %% -spec mk_moves([_], [_]) -> [#icode_move{}]. %% mk_moves([], []) -> %% []; %% mk_moves([X|Xs], [Y|Ys]) -> %% [mk_move(X, Y) | mk_moves(Xs, Ys)]. %% %% Makes a series of element operations. %% %% mk_elements(_, []) -> %% []; %% mk_elements(Tuple, [X|Xs]) -> %% [mk_primop([X], #unsafe_element{index=length(Xs)+1}, [Tuple]) | %% mk_elements(Tuple, Xs)]. %% %% @doc Removes comments from Icode. %% -spec strip_comments(icode()) -> icode(). strip_comments(ICode) -> icode_code_update(ICode, no_comments(icode_code(ICode))). %% The following spec is underspecified: the resulting list does not %% contain any #comment{} instructions -spec no_comments(icode_instrs()) -> icode_instrs(). no_comments([]) -> []; no_comments([I|Xs]) -> case is_comment(I) of true -> no_comments(Xs); false -> [I|no_comments(Xs)] end. %%----------------------------------------------------------------------- %% @doc True if an Icode instruction is safe (can be removed if the %% result is not used). Note that pure control flow instructions %% cannot be regarded as safe, as they are not defining anything. -spec is_safe(icode_instr()) -> boolean(). is_safe(Instr) -> case Instr of %% Instructions that are safe, or might be safe to remove. #icode_move{} -> true; #icode_phi{} -> true; #icode_begin_handler{} -> true; #icode_call{} -> case call_fun(Instr) of {M,F,A} -> erl_bifs:is_safe(M,F,A); Op -> hipe_icode_primops:is_safe(Op) end; %% Control flow instructions. #icode_if{} -> false; #icode_switch_val{} -> false; #icode_switch_tuple_arity{} -> false; #icode_type{} -> false; #icode_goto{} -> false; #icode_label{} -> false; %% Returning instructions without defines. #icode_return{} -> false; #icode_fail{} -> false; #icode_enter{} -> false; %% Internal auxiliary instructions that should not be removed %% unless you really know what you are doing. #icode_comment{} -> false; #icode_begin_try{} -> false; #icode_end_try{} -> false end. %% @doc Produces a simplified instruction sequence that is equivalent to [Instr] %% under the assumption that all results of Instr are unused, or 'false' if %% there is no such sequence (other than [Instr] itself). -spec reduce_unused(icode_instr()) -> false | [icode_instr()]. reduce_unused(Instr) -> case is_safe(Instr) of true -> []; false -> false end. %%----------------------------------------------------------------------- -spec highest_var(icode_instrs()) -> non_neg_integer(). highest_var(Instrs) -> highest_var(Instrs, 0). -spec highest_var(icode_instrs(), non_neg_integer()) -> non_neg_integer(). highest_var([I|Is], Max) -> Defs = defines(I), Uses = uses(I), highest_var(Is, new_max(Defs++Uses, Max)); highest_var([], Max) -> Max. -spec new_max([#icode_variable{}], non_neg_integer()) -> non_neg_integer(). new_max([V|Vs], Max) -> VName = case is_var(V) of true -> var_name(V); false -> case is_fvar(V) of true -> fvar_name(V); _ -> reg_name(V) end end, new_max(Vs, erlang:max(VName, Max)); new_max([], Max) when is_integer(Max) -> Max. %%----------------------------------------------------------------------- -spec highest_label(icode_instrs()) -> icode_lbl(). highest_label(Instrs) -> highest_label(Instrs, 0). -spec highest_label(icode_instrs(), icode_lbl()) -> icode_lbl(). highest_label([I|Is], Max) -> case is_label(I) of true -> L = label_name(I), NewMax = erlang:max(L, Max), highest_label(Is, NewMax); false -> highest_label(Is, Max) end; highest_label([], Max) when is_integer(Max) -> Max. %%-----------------------------------------------------------------------