%% -*- erlang-indent-level: 2 -*- %% %% %CopyrightBegin% %% %% Copyright Ericsson AB 2007-2013. All Rights Reserved. %% %% 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 online 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. %% %% %CopyrightEnd% %% %%%------------------------------------------------------------------- %%% File : hipe_icode_range.erl %%% Author : Per Gustafsson <pergu@it.uu.se> %%% Description : %%% %%% Created : 12 Mar 2007 by Per Gustafsson <pergu@it.uu.se> %%%------------------------------------------------------------------- -module(hipe_icode_range). -export([cfg/4]). %%===================================================================== %% Icode Coordinator Behaviour Callbacks %%===================================================================== -export([replace_nones/1, update__info/2, new__info/1, return__info/1, return_none/0, return_none_args/2, return_any_args/2]). %%===================================================================== -import(erl_types, [t_any/0, t_from_range_unsafe/2, t_inf/2, t_integer/0, t_to_string/1, t_to_tlist/1, t_limit/2, t_none/0, number_min/1, number_max/1]). -include("hipe_icode.hrl"). -include("hipe_icode_primops.hrl"). -include("../main/hipe.hrl"). -include("../flow/cfg.hrl"). -include("../flow/hipe_bb.hrl"). -include("hipe_icode_type.hrl"). -type range_tuple() :: {'neg_inf' | integer(), 'pos_inf' | integer()}. -type range_rep() :: range_tuple() | 'empty'. -type fun_name() :: atom() | tuple(). -type inf_integer() :: 'neg_inf' | 'pos_inf' | integer(). -record(range, {range :: range_rep(), other :: boolean()}). -type range() :: #range{}. -record(ann, {range :: range(), type :: erl_types:erl_type(), count :: integer()}). -type ann() :: #ann{}. -type range_anno() :: {'range_anno', ann(), fun((ann()) -> string())}. -type args_fun() :: fun((mfa(), cfg()) -> [range()]). -type call_fun() :: fun((mfa(), [range()]) -> range()). -type final_fun() :: fun((mfa(), [range()]) -> 'ok'). -type data() :: {mfa(), args_fun(), call_fun(), final_fun()}. -type label() :: non_neg_integer(). -type info() :: gb_tree(). -type work_list() :: {[label()], [label()], set()}. -type variable() :: #icode_variable{}. -type annotated_variable() :: #icode_variable{}. -type argument() :: #icode_const{} | variable(). -type three_range_fun() :: fun((range(),range(),range()) -> range()). -type instr_split_info() :: {icode_instr(), [{label(),info()}]}. -type last_instr_return() :: {instr_split_info(), range()}. -record(state, {info_map = gb_trees:empty() :: info(), counter = dict:new() :: dict(), cfg :: cfg(), liveness = gb_trees:empty() :: gb_tree(), ret_type :: range(), lookup_fun :: call_fun(), result_action :: final_fun()}). -define(WIDEN, 1). -define(TAG_IMMED1_SIZE, 4). -define(BITS, 64). %%--------------------------------------------------------------------- -spec cfg(cfg(), mfa(), comp_options(), #comp_servers{}) -> cfg(). cfg(Cfg, MFA, Options, Servers) -> case proplists:get_bool(concurrent_comp, Options) of true -> concurrent_cfg(Cfg, MFA, Servers#comp_servers.range); false -> ordinary_cfg(Cfg, MFA) end. -spec concurrent_cfg(cfg(), mfa(), pid()) -> cfg(). concurrent_cfg(Cfg, MFA, CompServer) -> CompServer ! {ready, {MFA, self()}}, {ArgsFun, CallFun, FinalFun} = do_analysis(Cfg, MFA), Ans = do_rewrite(Cfg, MFA, ArgsFun, CallFun, FinalFun), CompServer ! {done_rewrite, MFA}, Ans. -spec do_analysis(cfg(), mfa()) -> {args_fun(), call_fun(), final_fun()}. do_analysis(Cfg, MFA) -> receive {analyse, {ArgsFun, CallFun, FinalFun}} -> analyse(Cfg, {MFA, ArgsFun, CallFun, FinalFun}), do_analysis(Cfg, MFA); {done, {_NewArgsFun, _NewCallFun, _NewFinalFun} = T} -> T end. -spec do_rewrite(cfg(), mfa(), args_fun(), call_fun(), final_fun()) -> cfg(). do_rewrite(Cfg, MFA, ArgsFun, CallFun, FinalFun) -> common_rewrite(Cfg, {MFA, ArgsFun, CallFun, FinalFun}). -spec ordinary_cfg(cfg(), mfa()) -> cfg(). ordinary_cfg(Cfg, MFA) -> Data = make_data(Cfg,MFA), common_rewrite(Cfg, Data). -spec common_rewrite(cfg(), data()) -> cfg(). common_rewrite(Cfg, Data) -> State = safe_analyse(Cfg, Data), State2 = rewrite_blocks(State), Cfg1 = state__cfg(State2), Cfg2 = hipe_icode_cfg:remove_unreachable_code(Cfg1), Cfg3 = convert_cfg_to_types(Cfg2), hipe_icode_type:specialize(Cfg3). -spec make_data(cfg(), mfa()) -> data(). make_data(Cfg, {_M,_F,A}=MFA) -> NoArgs = case hipe_icode_cfg:is_closure(Cfg) of true -> hipe_icode_cfg:closure_arity(Cfg)+1; false -> A end, Args = lists:duplicate(NoArgs, any_type()), ArgsFun = fun(_,_) -> Args end, CallFun = fun(_,_) -> any_type() end, FinalFun = fun(_,_) -> ok end, {MFA, ArgsFun, CallFun, FinalFun}. -spec analyse(cfg(), data()) -> 'ok'. analyse(Cfg, Data) -> try #state{} = safe_analyse(Cfg, Data), ok catch throw:no_input -> ok end. -spec safe_analyse(cfg(), data()) -> #state{}. safe_analyse(CFG, Data={MFA,_,_,_}) -> State = state__init(CFG, Data), Work = init_work(State), NewState = analyse_blocks(State, Work), (state__result_action(NewState))(MFA, [state__ret_type(NewState)]), NewState. -spec rewrite_blocks(#state{}) -> #state{}. rewrite_blocks(State) -> CFG = state__cfg(State), Start = hipe_icode_cfg:start_label(CFG), rewrite_blocks([Start], State, [Start]). -spec rewrite_blocks([label()], #state{}, [label()]) -> #state{}. rewrite_blocks([Next|Rest], State, Visited) -> Info = state__info_in(State, Next), {NewState, NewLabels} = analyse_block(Next, Info, State, true), NewLabelsSet = ordsets:from_list(NewLabels), RealNew = ordsets:subtract(NewLabelsSet, Visited), NewVisited = ordsets:union([RealNew, Visited, [Next]]), NewWork = ordsets:union([RealNew, Rest]), rewrite_blocks(NewWork, NewState, NewVisited); rewrite_blocks([], State, _) -> State. -spec analyse_blocks(#state{}, work_list()) -> #state{}. analyse_blocks(State, Work) -> case get_work(Work) of fixpoint -> State; {Label, NewWork} -> Info = state__info_in(State, Label), {NewState, NewLabels} = try analyse_block(Label, Info, State, false) catch throw:none_range -> {State, []} end, NewWork2 = add_work(NewWork, NewLabels), analyse_blocks(NewState, NewWork2) end. -spec analyse_block(label(), info(), #state{}, boolean()) -> {#state{}, [label()]}. analyse_block(Label, Info, State, Rewrite) -> BB = state__bb(State, Label), Code = hipe_bb:code(BB), {NewCode, InfoList, RetType} = analyse_BB(Code, Info, [], Rewrite, state__lookup_fun(State)), State1 = state__bb_add(State, Label, hipe_bb:mk_bb(NewCode)), State2 = state__ret_type_update(State1, RetType), state__update_info(State2, InfoList, Rewrite). -spec analyse_BB([icode_instr()], info(), [icode_instr()], boolean(), call_fun()) -> {[icode_instr()], [{label(),info()}], range()}. analyse_BB([Last], Info, Code, Rewrite, LookupFun) -> {{NewI, LabelInfoList}, RetType} = analyse_last_insn(Last, Info, Rewrite, LookupFun), {lists:reverse([NewI|Code]), LabelInfoList, RetType}; analyse_BB([Insn|InsnList], Info, Code, Rewrite, LookupFun) -> {NewInfo, NewI} = analyse_insn(Insn, Info, LookupFun), analyse_BB(InsnList, NewInfo, [NewI|Code], Rewrite, LookupFun). -spec analyse_insn(icode_instr(), info(), call_fun()) -> {info(), icode_instr()}. analyse_insn(I, Info, LookupFun) -> %% io:format("~w Info: ~p~n", [I, Info]), NewI = handle_args(I,Info), FinalI = case NewI of #icode_call{} -> analyse_call(NewI, LookupFun); #icode_move{} -> analyse_move(NewI); #icode_phi{} -> analyse_phi(NewI); #icode_begin_handler{} -> analyse_begin_handler(NewI); #icode_comment{} -> NewI end, {enter_vals(FinalI, Info), FinalI}. -spec handle_args(icode_instr(), info()) -> icode_instr(). handle_args(I, Info) -> WidenFun = fun update_three/3, handle_args(I, Info, WidenFun). -spec handle_args(icode_instr(), info(), three_range_fun()) -> icode_instr(). handle_args(I, Info, WidenFun) -> Uses = hipe_icode:uses(I), PresentRanges = [lookup(V, Info) || V <- Uses], %% io:format("Uses: ~p~nRanges: ~p~n", [Uses, PresentRanges]), JoinFun = fun(Var, Range) -> update_info(Var, Range, WidenFun) end, NewUses = lists:zipwith(JoinFun, Uses, PresentRanges), hipe_icode:subst_uses(lists:zip(Uses, NewUses), I). -spec join_info(ann(), range(), three_range_fun()) -> ann(). join_info(Ann = #ann{range = R1, type = Type, count = ?WIDEN}, R2, Fun) -> Ann#ann{range = Fun(R1, R2, range_from_simple_type(Type))}; join_info(Ann = #ann{range = R1, type = Type, count = C}, R2, _Fun) when C < ?WIDEN -> case join_three(R1, R2, range_from_simple_type(Type)) of R1 -> Ann; NewR -> Ann#ann{range = NewR, count = C+1} end. -spec join_three(range(), range(), range()) -> range(). join_three(R1, R2, R3) -> inf(sup(R1, R2), R3). -spec update_info(variable(), range()) -> annotated_variable(). update_info(Var, Range) -> update_info(Var, Range, fun update_three/3). -spec update_info(variable(), range(), three_range_fun()) -> annotated_variable(). update_info(Arg, R, Fun) -> case hipe_icode:is_annotated_variable(Arg) of true -> Ann = hipe_icode:variable_annotation(Arg), hipe_icode:annotate_variable(Arg, update_info1(Ann, R, Fun)); false -> Arg end. -spec update_info1(any(), range(), three_range_fun()) -> range_anno(). update_info1({range_anno, Ann, _}, R2, Fun) -> make_range_anno(update_ann(Ann,R2,Fun)); update_info1({type_anno, Type, _}, R2, Fun) -> make_range_anno(update_ann(type_to_ann(Type), R2, Fun)). update_ann(Ann = #ann{range = R1, type = Type, count = ?WIDEN}, R2, Fun) -> Ann#ann{range = Fun(R1,R2,range_from_simple_type(Type))}; update_ann(Ann = #ann{range = R1, type = Type, count = C}, R2, _Fun) -> case update_three(R1, R2, range_from_simple_type(Type)) of R1 -> Ann; NewR -> Ann#ann{range = NewR, count = C+1} end. -spec type_to_ann(erl_types:erl_type()) -> ann(). type_to_ann(Type) -> #ann{range = range_from_simple_type(Type), type = t_limit(Type,1), count = 1}. -spec make_range_anno(ann()) -> range_anno(). make_range_anno(Ann) -> {range_anno, Ann, fun pp_ann/1}. -spec update_three(range(), range(), range()) -> range(). update_three(_R1, R2, R3) -> inf(R2, R3). -spec safe_widen(range(), range(), range()) -> range(). safe_widen(#range{range=Old}, #range{range=New}, T = #range{range=Wide}) -> ResRange = case {Old, New, Wide} of {{Min,Max1}, {Min,Max2}, {_,Max}} -> case inf_geq(OMax = next_up_limit(inf_max([Max1, Max2])), Max) of true -> {Min,Max}; false -> {Min,OMax} end; {{Min1,Max}, {Min2,Max}, {Min,_}} -> case inf_geq(Min, OMin = next_down_limit(inf_min([Min1, Min2]))) of true -> {Min,Max}; false -> {OMin,Max} end; {{Min1,Max1}, {Min2,Max2}, {Min,Max}} -> RealMax = case inf_geq(OMax = next_up_limit(inf_max([Max1, Max2])), Max) of true -> Max; false -> OMax end, RealMin = case inf_geq(Min, OMin = next_down_limit(inf_min([Min1, Min2]))) of true -> Min; false -> OMin end, {RealMin, RealMax}; _ -> Wide end, T#range{range = ResRange}. -spec widen(range(), range(), range()) -> range(). widen(#range{range=Old}, #range{range=New}, T = #range{range=Wide}) -> ResRange = case {Old, New, Wide} of {{Min,_}, {Min,Max2}, {_,Max}} -> case inf_geq(OMax = next_up_limit(Max2), Max) of true -> {Min,Max}; false -> {Min,OMax} end; {{_,Max}, {Min2,Max}, {Min,_}} -> case inf_geq(Min, OMin = next_down_limit(Min2)) of true -> {Min,Max}; false -> {OMin,Max} end; {_, {Min2,Max2}, {Min,Max}} -> RealMax = case inf_geq(OMax = next_up_limit(Max2), Max) of true -> Max; false -> OMax end, RealMin = case inf_geq(Min, OMin = next_down_limit(Min2)) of true -> Min; false -> OMin end, {RealMin, RealMax}; _ -> Wide end, T#range{range = ResRange}. -spec analyse_call(#icode_call{}, call_fun()) -> #icode_call{}. analyse_call(Call, LookupFun) -> case hipe_icode:call_dstlist(Call) of [] -> Call; Dsts -> Args = hipe_icode:args(Call), Fun = hipe_icode:call_fun(Call), Type = hipe_icode:call_type(Call), DstRanges = analyse_call_or_enter_fun(Fun, Args, Type, LookupFun), NewDefs = [update_info(Var, R) || {Var,R} <- lists:zip(Dsts, DstRanges)], hipe_icode:subst_defines(lists:zip(Dsts, NewDefs), Call) end. -spec analyse_move(#icode_move{}) -> #icode_move{}. analyse_move(Move) -> Src = hipe_icode:move_src(Move), Dst = hipe_icode:move_dst(Move), Range = get_range_from_arg(Src), NewDst = update_info(Dst, Range), hipe_icode:subst_defines([{Dst,NewDst}], Move). -spec analyse_begin_handler(#icode_begin_handler{}) -> #icode_begin_handler{}. analyse_begin_handler(Handler) -> SubstList = [{Dst, update_info(Dst, any_type())} || Dst <- hipe_icode:begin_handler_dstlist(Handler)], hipe_icode:subst_defines(SubstList, Handler). -spec analyse_phi(#icode_phi{}) -> #icode_phi{}. analyse_phi(Phi) -> {_, Args} = lists:unzip(hipe_icode:phi_arglist(Phi)), Dst = hipe_icode:phi_dst(Phi), ArgRanges = get_range_from_args(Args), %% io:format("Phi-Arg_ranges: ~p ~n", [Arg_ranges]), DstRange = sup(ArgRanges), NewDst = update_info(Dst, DstRange, fun widen/3), hipe_icode:subst_defines([{Dst, NewDst}], Phi). -spec analyse_last_insn(icode_instr(), info(), boolean(), call_fun()) -> last_instr_return(). analyse_last_insn(I, Info, Rewrite, LookupFun) -> %% io:format("~w Info: ~p~n",[I,Info]), NewI = handle_args(I, Info), %% io:format("~w -> ~w~n",[NewI,I]), case NewI of #icode_return{} -> analyse_return(NewI, Info); #icode_enter{} -> analyse_enter(NewI, Info, LookupFun); #icode_switch_val{} -> {analyse_switch_val(NewI, Info, Rewrite), none_type()}; #icode_if{} -> {analyse_if(NewI, Info, Rewrite), none_type()}; #icode_goto{} -> {analyse_goto(NewI, Info), none_type()}; #icode_type{} -> {analyse_type(NewI, Info, Rewrite), none_type()}; #icode_fail{} -> {analyse_fail(NewI, Info), none_type()}; #icode_call{} -> {analyse_last_call(NewI, Info, LookupFun), none_type()}; #icode_switch_tuple_arity{} -> {analyse_switch_tuple_arity(NewI, Info), none_type()}; #icode_begin_try{} -> {analyse_begin_try(NewI, Info), none_type()} end. -spec analyse_return(#icode_return{}, info()) -> last_instr_return(). analyse_return(Insn, _Info) -> [RetRange] = get_range_from_args(hipe_icode:return_vars(Insn)), {{Insn,[]}, RetRange}. -spec analyse_enter(#icode_enter{}, info(), call_fun()) -> last_instr_return(). analyse_enter(Insn, _Info, LookupFun) -> Args = hipe_icode:args(Insn), Fun = hipe_icode:enter_fun(Insn), CallType = hipe_icode:enter_type(Insn), [RetRange] = analyse_call_or_enter_fun(Fun, Args, CallType, LookupFun), {{Insn,[]}, RetRange}. -spec analyse_switch_val(#icode_switch_val{}, info(), boolean()) -> instr_split_info(). analyse_switch_val(Switch, Info, Rewrite) -> Var = hipe_icode:switch_val_term(Switch), SwitchRange = get_range_from_arg(Var), Cases = hipe_icode:switch_val_cases(Switch), {FailRange, LabelRangeList} = get_range_label_list(Cases, SwitchRange, []), case range__is_none(FailRange) of true -> InfoList = update_infos(Var, Info, LabelRangeList), if Rewrite -> {update_switch(Switch, LabelRangeList, false), InfoList}; true -> {Switch, InfoList} end; false -> FailLabel = hipe_icode:switch_val_fail_label(Switch), InfoList = update_infos(Var, Info, [{FailRange, FailLabel}|LabelRangeList]), if Rewrite -> {update_switch(Switch, LabelRangeList, true), InfoList}; true -> {Switch, InfoList} end end. -spec update_infos(argument(), info(), [{range(),label()}]) -> [{label(),info()}]. update_infos(Arg, Info, [{Range, Label}|Rest]) -> [{Label,enter_define({Arg,Range},Info)} | update_infos(Arg, Info, Rest)]; update_infos(_, _, []) -> []. -spec get_range_label_list([{argument(),label()}], range(), [{range(),label()}]) -> {range(),[{range(),label()}]}. get_range_label_list([{Val,Label}|Cases], SRange, Acc) -> VRange = get_range_from_arg(Val), None = none_type(), case inf(SRange, VRange) of None -> get_range_label_list(Cases, SRange, Acc); ResRange -> get_range_label_list(Cases, SRange, [{ResRange,Label}|Acc]) end; get_range_label_list([], SRange, Acc) -> {PointTypes, _} = lists:unzip(Acc), {remove_point_types(SRange, PointTypes), Acc}. -spec update_switch(#icode_switch_val{}, [{range(),label()}], boolean()) -> #icode_switch_val{}. update_switch(Switch, LabelRangeList, KeepFail) -> S2 = case label_range_list_to_cases(LabelRangeList, []) of no_update -> Switch; Cases -> hipe_icode:switch_val_cases_update(Switch, Cases) end, if KeepFail -> S2; true -> S2 end. -spec label_range_list_to_cases([{range(),label()}], [{#icode_const{},label()}]) -> 'no_update' | [{#icode_const{},label()}]. label_range_list_to_cases([{#range{range={C,C},other=false},Label}|Rest], Acc) when is_integer(C) -> label_range_list_to_cases(Rest, [{hipe_icode:mk_const(C),Label}|Acc]); label_range_list_to_cases([{_NotAConstantRange,_Label}|_Rest], _Acc) -> no_update; label_range_list_to_cases([], Acc) -> lists:reverse(Acc). -spec analyse_switch_tuple_arity(#icode_switch_tuple_arity{}, info()) -> {#icode_switch_tuple_arity{}, [{label(),info()}]}. analyse_switch_tuple_arity(Switch, Info) -> Var = hipe_icode:switch_tuple_arity_term(Switch), NewInfo = enter_define({Var, get_range_from_arg(Var)}, Info), Cases = hipe_icode:switch_tuple_arity_cases(Switch), Fail = hipe_icode:switch_tuple_arity_fail_label(Switch), {_, Case_labels} = lists:unzip(Cases), Labels = [Fail|Case_labels], {Switch, [{Label,NewInfo} || Label <- Labels]}. -spec analyse_goto(#icode_goto{}, info()) -> {#icode_goto{}, [{label(),info()},...]}. analyse_goto(Insn, Info) -> GotoLabel = hipe_icode:goto_label(Insn), {Insn, [{GotoLabel,Info}]}. -spec analyse_fail(#icode_fail{}, info()) -> {#icode_fail{}, [{label(),info()}]}. analyse_fail(Fail, Info) -> case hipe_icode:fail_label(Fail) of [] -> {Fail, []}; Label -> {Fail, [{Label,Info}]} end. -spec analyse_begin_try(#icode_begin_try{}, info()) -> {#icode_begin_try{}, [{label(),info()},...]}. analyse_begin_try(Insn, Info) -> Label = hipe_icode:begin_try_label(Insn), Successor = hipe_icode:begin_try_successor(Insn), {Insn, [{Label,Info},{Successor,Info}]}. -spec analyse_last_call(#icode_call{}, info(), call_fun()) -> {#icode_call{}, [{label(),info()},...]}. analyse_last_call(Call, Info, LookupFun) -> %% hipe_icode_pp:pp_block([Insn]), NewI = analyse_call(Call, LookupFun), Continuation = hipe_icode:call_continuation(Call), NewInfo = enter_vals(NewI, Info), case hipe_icode:call_fail_label(Call) of [] -> {NewI, [{Continuation, NewInfo}]}; Fail -> {NewI, [{Continuation, NewInfo}, {Fail, Info}]} end. -spec analyse_if(#icode_if{}, info(), boolean()) -> {#icode_goto{} | #icode_if{}, [{label(),info()}]}. analyse_if(If, Info, Rewrite) -> case hipe_icode:if_args(If) of [_, _] = Args -> analyse_sane_if(If, Info, Args, get_range_from_args(Args), Rewrite); _ -> TrueLabel = hipe_icode:if_true_label(If), FalseLabel = hipe_icode:if_false_label(If), {If, [{TrueLabel, Info}, {FalseLabel, Info}]} end. -spec analyse_sane_if(#icode_if{}, info(), [argument(),...], [range(),...], boolean()) -> {#icode_goto{} | #icode_if{}, [{label(), info()}]}. analyse_sane_if(If, Info, [Arg1, Arg2], [Range1, Range2], Rewrite) -> case normalize_name(hipe_icode:if_op(If)) of '>' -> {TrueRange2, TrueRange1, FalseRange2, FalseRange1} = range_inequality_propagation(Range2, Range1); '<' -> {TrueRange1, TrueRange2, FalseRange1, FalseRange2} = range_inequality_propagation(Range1, Range2); '>=' -> {FalseRange1, FalseRange2, TrueRange1, TrueRange2} = range_inequality_propagation(Range1, Range2); '=<' -> {FalseRange2, FalseRange1, TrueRange2, TrueRange1} = range_inequality_propagation(Range2, Range1); '=:=' -> {TrueRange1, TrueRange2, FalseRange1, FalseRange2} = range_equality_propagation(Range1, Range2); '=/=' -> {FalseRange1, FalseRange2, TrueRange1, TrueRange2} = range_equality_propagation(Range1, Range2); '==' -> {TempTrueRange1, TempTrueRange2, FalseRange1, FalseRange2} = range_equality_propagation(Range1, Range2), TrueRange1 = set_other(TempTrueRange1, other(Range1)), TrueRange2 = set_other(TempTrueRange2, other(Range2)); '/=' -> {TempFalseRange1, TempFalseRange2, TrueRange1, TrueRange2} = range_equality_propagation(Range1, Range2), FalseRange1 = set_other(TempFalseRange1, other(Range1)), FalseRange2 = set_other(TempFalseRange2, other(Range2)) end, %% io:format("TR1 = ~w\nTR2 = ~w\n", [TrueRange1, TrueRange2]), True = case lists:all(fun range__is_none/1, [TrueRange1, TrueRange2]) of true -> []; false -> TrueLabel = hipe_icode:if_true_label(If), TrueArgRanges = [{Arg1, TrueRange1}, {Arg2, TrueRange2}], TrueInfo = enter_defines(TrueArgRanges, Info), [{TrueLabel, TrueInfo}] end, %% io:format("FR1 = ~w\nFR2 = ~w\n", [FalseRange1, FalseRange2]), False = case lists:all(fun range__is_none/1, [FalseRange1, FalseRange2]) of true -> []; false -> FalseLabel = hipe_icode:if_false_label(If), FalseArgRanges = [{Arg1, FalseRange1}, {Arg2, FalseRange2}], FalseInfo = enter_defines(FalseArgRanges, Info), [{FalseLabel, FalseInfo}] end, UpdateInfo = True ++ False, NewIF = if Rewrite -> case UpdateInfo of [] -> %% This is weird If; [{Label, _Info}] -> hipe_icode:mk_goto(Label); [_, _] -> If end; true -> If end, {NewIF, UpdateInfo}. -spec normalize_name(atom()) -> atom(). normalize_name(Name) -> case Name of 'fixnum_eq' -> '=:='; 'fixnum_neq' -> '=/='; 'fixnum_gt' -> '>'; 'fixnum_lt' -> '<'; 'fixnum_ge' -> '>='; 'fixnum_le' -> '=<'; Name -> Name end. -spec range_equality_propagation(range(), range()) -> {range(), range(), range(), range()}. range_equality_propagation(Range_1, Range_2) -> True_range = inf(Range_1, Range_2), case {range(Range_1), range(Range_2)} of {{N,N}, {N,N}} -> False_range_1 = none_range(), False_range_2 = none_range(); {{N1,N1}, {N2,N2}} -> False_range_1 = Range_1, False_range_2 = Range_2; {{N,N}, _} -> False_range_1 = Range_1, {_,False_range_2} = compare_with_integer(N, Range_2); {_, {N,N}} -> False_range_2 = Range_2, {_,False_range_1} = compare_with_integer(N, Range_1); {_, _} -> False_range_1 = Range_1, False_range_2 = Range_2 end, {True_range, True_range, False_range_1, False_range_2}. -spec range_inequality_propagation(range(), range()) -> {range(), range(), range(), range()}. %% Range1 < Range2 range_inequality_propagation(Range1, Range2) -> R1_other = other(Range1), R2_other = other(Range2), {R1_true_range, R1_false_range, R2_true_range, R2_false_range} = case {range(Range1), range(Range2)} of {{N1,N1}, {N2,N2}} -> case inf_geq(N2,inf_add(N1,1)) of true -> {{N1,N1},empty,{N2,N2},empty}; false -> {empty,{N1,N1},empty,{N2,N2}} end; {{N1,N1}, {Min2,Max2}} -> case inf_geq(Min2,inf_add(N1,1)) of true -> {{N1,N1},empty,{inf_add(N1,1),Max2},empty}; false -> case inf_geq(N1,Max2) of true -> {empty,{N1,N1},empty,{Min2,N1}}; false -> {{N1,N1},{N1,N1},{inf_add(N1,1),Max2},{Min2,N1}} end end; {{Min1,Max1}, {N2,N2}} -> case inf_geq(N2,inf_add(Max1,1)) of true -> {{Min1,inf_add(N2,-1)},empty,{N2,N2},empty}; false -> case inf_geq(Min1,N2) of true -> {empty,{N2,Max1},empty,{N2,N2}}; false -> {{Min1,inf_add(N2,-1)},{N2,Max1},{N2,N2},{N2,N2}} end end; {empty, {Min2,Max2}} -> {empty,empty,{Min2,Max2},{Min2,Max2}}; {{Min1,Max1}, empty} -> {{Min1,Max1},{Min1,Max1},empty,empty}; {empty, empty} -> {empty,empty,empty,empty}; {{Min1,Max1}, {Min2,Max2}} -> {{Min1,inf_min([Max1,inf_add(Max2,-1)])}, {inf_max([Min1,Min2]),Max1}, {inf_max([inf_add(Min1,1),Min2]),Max2}, {Min2,inf_min([Max1,Max2])}} end, {range_init(R1_true_range, R1_other), range_init(R2_true_range, R2_other), range_init(R1_false_range, R1_other), range_init(R2_false_range, R2_other)}. -spec analyse_type(#icode_type{}, info(), boolean()) -> {#icode_goto{} | #icode_type{}, [{label(),info()}]}. analyse_type(Type, Info, Rewrite) -> TypeTest = hipe_icode:type_test(Type), [Arg|_] = hipe_icode:type_args(Type), OldVarRange = get_range_from_arg(Arg), case TypeTest of {integer, N} -> {TrueRange,FalseRange} = compare_with_integer(N,OldVarRange); integer -> TrueRange = inf(any_range(), OldVarRange), FalseRange = inf(none_range(), OldVarRange); number -> TrueRange = FalseRange = OldVarRange; _ -> TrueRange = inf(none_range(), OldVarRange), FalseRange = OldVarRange end, TrueLabel = hipe_icode:type_true_label(Type), FalseLabel = hipe_icode:type_false_label(Type), TrueInfo = enter_define({Arg, TrueRange}, Info), FalseInfo = enter_define({Arg, FalseRange}, Info), True = case range__is_none(TrueRange) of true -> []; false -> [{TrueLabel, TrueInfo}] end, False = case range__is_none(FalseRange) of true -> []; false -> [{FalseLabel, FalseInfo}] end, UpdateInfo = True ++ False, NewType = if Rewrite -> case UpdateInfo of [] -> %% This is weird Type; [{Label,_Info}] -> hipe_icode:mk_goto(Label); [_, _] -> Type end; true -> Type end, {NewType, True ++ False}. -spec compare_with_integer(integer(), range()) -> {range(), range()}. compare_with_integer(N, OldVarRange) -> TestRange = range_init({N, N}, false), TrueRange = inf(TestRange, OldVarRange), %% False range TempFalseRange = range__remove_constant(OldVarRange, TestRange), BetterRange = case range(TempFalseRange) of {Min, Max} = MM -> New_small = inf_geq(Min, N), New_large = inf_geq(N, Max), if New_small and not New_large -> {N + 1, Max}; New_large and not New_small -> {Min, N - 1}; true -> MM end; Not_tuple -> Not_tuple end, FalseRange = range_init(BetterRange, other(TempFalseRange)), {TrueRange, FalseRange}. %%== Ranges ================================================================== -spec pp_ann(ann() | erl_types:erl_type()) -> string(). pp_ann(#ann{range = #range{range = R, other = false}}) -> pp_range(R); pp_ann(#ann{range = #range{range = empty, other = true}, type = Type}) -> t_to_string(Type); pp_ann(#ann{range = #range{range = R, other = true}, type = Type}) -> pp_range(R) ++ " | " ++ t_to_string(Type); pp_ann(Type) -> t_to_string(Type). -spec pp_range(range_rep()) -> nonempty_string(). pp_range(empty) -> "none"; pp_range({Min, Max}) -> val_to_string(Min) ++ ".." ++ val_to_string(Max). -spec val_to_string('pos_inf' | 'neg_inf' | integer()) -> string(). val_to_string(pos_inf) -> "inf"; val_to_string(neg_inf) -> "-inf"; val_to_string(X) when is_integer(X) -> integer_to_list(X). -spec range_from_type(erl_types:erl_type()) -> [range()]. range_from_type(Type) -> [range_from_simple_type(T) || T <- t_to_tlist(Type)]. -spec range_from_simple_type(erl_types:erl_type()) -> range(). range_from_simple_type(Type) -> None = t_none(), case t_inf(t_integer(), Type) of None -> #range{range = empty, other = true}; Type -> Range = {number_min(Type), number_max(Type)}, #range{range = Range, other = false}; NewType -> Range = {number_min(NewType), number_max(NewType)}, #range{range = Range, other = true} end. -spec range_init(range_rep(), boolean()) -> range(). range_init({Min, Max} = Range, Other) -> case inf_geq(Max, Min) of true -> #range{range = Range, other = Other}; false -> #range{range = empty, other = Other} end; range_init(empty, Other) -> #range{range = empty, other = Other}. -spec range(range()) -> range_rep(). range(#range{range = R}) -> R. -spec other(range()) -> boolean(). other(#range{other = O}) -> O. -spec set_other(range(), boolean()) -> range(). set_other(R, O) -> R#range{other = O}. -spec range__min(range()) -> 'empty' | 'neg_inf' | integer(). range__min(#range{range = empty}) -> empty; range__min(#range{range = {Min,_}}) -> Min. -spec range__max(range()) -> 'empty' | 'pos_inf' | integer(). range__max(#range{range = empty}) -> empty; range__max(#range{range = {_,Max}}) -> Max. -spec range__is_none(range()) -> boolean(). range__is_none(#range{range = empty, other = false}) -> true; range__is_none(#range{}) -> false. -spec range__is_empty(range()) -> boolean(). range__is_empty(#range{range = empty}) -> true; range__is_empty(#range{range = {_,_}}) -> false. -spec remove_point_types(range(), [range()]) -> range(). remove_point_types(Range, Ranges) -> Sorted = lists:sort(Ranges), FoldFun = fun (R, Acc) -> range__remove_constant(Acc,R) end, Range1 = lists:foldl(FoldFun, Range, Sorted), lists:foldl(FoldFun, Range1, lists:reverse(Sorted)). -spec range__remove_constant(range(), range()) -> range(). range__remove_constant(#range{range = {C, C}} = R, #range{range = {C, C}}) -> R#range{range = empty}; range__remove_constant(#range{range = {C, H}} = R, #range{range = {C, C}}) -> R#range{range = {C+1, H}}; range__remove_constant(#range{range = {L, C}} = R, #range{range = {C, C}}) -> R#range{range = {L, C-1}}; range__remove_constant(#range{} = R, #range{range = {C,C}}) -> R; range__remove_constant(#range{} = R, _) -> R. -spec any_type() -> range(). any_type() -> #range{range = any_r(), other = true}. -spec any_range() -> range(). any_range() -> #range{range = any_r(), other = false}. -spec none_range() -> range(). none_range() -> #range{range = empty, other = true}. -spec none_type() -> range(). none_type() -> #range{range = empty, other = false}. -spec any_r() -> {'neg_inf','pos_inf'}. any_r() -> {neg_inf, pos_inf}. -spec get_range_from_args([argument()]) -> [range()]. get_range_from_args(Args) -> [get_range_from_arg(Arg) || Arg <- Args]. -spec get_range_from_arg(argument()) -> range(). get_range_from_arg(Arg) -> case hipe_icode:is_const(Arg) of true -> Value = hipe_icode:const_value(Arg), case is_integer(Value) of true -> #range{range = {Value, Value}, other = false}; false -> #range{range = empty, other = true} end; false -> case hipe_icode:is_annotated_variable(Arg) of true -> case hipe_icode:variable_annotation(Arg) of {range_anno, #ann{range = Range}, _} -> Range; {type_anno, Type, _} -> range_from_simple_type(Type) end; false -> any_type() end end. %% inf([R]) -> %% R; %% inf([R1,R2|Rest]) -> %% inf([inf(R1,R2)|Rest]). -spec inf(range(), range()) -> range(). inf(#range{range=R1, other=O1}, #range{range=R2, other=O2}) -> #range{range=range_inf(R1,R2), other=other_inf(O1,O2)}. -spec range_inf(range_rep(), range_rep()) -> range_rep(). range_inf(empty, _) -> empty; range_inf(_, empty) -> empty; range_inf({Min1,Max1}, {Min2,Max2}) -> NewMin = inf_max([Min1, Min2]), NewMax = inf_min([Max1, Max2]), case inf_geq(NewMax, NewMin) of true -> {NewMin, NewMax}; false -> empty end. -spec other_inf(boolean(), boolean()) -> boolean(). other_inf(O1, O2) -> O1 and O2. -spec sup([range(),...]) -> range(). sup([R]) -> R; sup([R1,R2|Rest]) -> sup([sup(R1, R2)|Rest]). -spec sup(range(), range()) -> range(). sup(#range{range=R1,other=O1}, #range{range=R2,other=O2}) -> #range{range=range_sup(R1,R2), other=other_sup(O1,O2)}. -spec range_sup(range_rep(), range_rep()) -> range_rep(). range_sup(empty, R) -> R; range_sup(R, empty) -> R; range_sup({Min1,Max1}, {Min2,Max2}) -> NewMin = inf_min([Min1,Min2]), NewMax = inf_max([Max1,Max2]), {NewMin,NewMax}. -spec other_sup(boolean(), boolean()) -> boolean(). other_sup(O1, O2) -> O1 or O2. %%== Call Support ============================================================= -spec analyse_call_or_enter_fun(fun_name(), [argument()], icode_call_type(), call_fun()) -> [range()]. analyse_call_or_enter_fun(Fun, Args, CallType, LookupFun) -> %%io:format("Fun: ~p~n Args: ~p~n CT: ~p~n LF: ~p~n", [Fun, Args, CallType, LookupFun]), case basic_type(Fun) of {bin, Operation} -> [Arg_range1,Arg_range2] = get_range_from_args(Args), A1_is_empty = range__is_empty(Arg_range1), A2_is_empty = range__is_empty(Arg_range2), case A1_is_empty orelse A2_is_empty of true -> [none_type()]; false -> [Operation(Arg_range1, Arg_range2)] end; {unary, Operation} -> [Arg_range] = get_range_from_args(Args), case range__is_empty(Arg_range) of true -> [none_type()]; false -> [Operation(Arg_range)] end; {fcall, MFA} -> case CallType of local -> Range = LookupFun(MFA, get_range_from_args(Args)), case range__is_none(Range) of true -> throw(none_range); false -> [Range] end; remote -> [any_type()] end; not_int -> [any_type()]; not_analysed -> [any_type()]; {hipe_bs_primop, {bs_get_integer, Size, Flags}} -> {Min, Max} = analyse_bs_get_integer(Size, Flags, length(Args) =:= 1), [#range{range = {Min, Max}, other = false}, any_type()]; {hipe_bs_primop, _} = Primop -> Type = hipe_icode_primops:type(Primop), range_from_type(Type) end. -type bin_operation() :: fun((range(), range()) -> range()). -type unary_operation() :: fun((range()) -> range()). -spec basic_type(fun_name()) -> 'not_int' | 'not_analysed' | {'bin', bin_operation()} | {'unary', unary_operation()} | {'fcall', mfa()} | {'hipe_bs_primop', _}. %% Arithmetic operations basic_type('+') -> {bin, fun(R1, R2) -> range_add(R1, R2) end}; basic_type('-') -> {bin, fun(R1, R2) -> range_sub(R1, R2) end}; basic_type('*') -> {bin, fun(R1, R2) -> range_mult(R1, R2) end}; basic_type('/') -> not_int; basic_type('div') -> {bin, fun(R1, R2) -> range_div(R1, R2) end}; basic_type('rem') -> {bin, fun(R1, R2) -> range_rem(R1, R2) end}; basic_type('bor') -> {bin, fun(R1, R2) -> range_bor(R1, R2) end}; basic_type('band') -> {bin, fun(R1, R2) -> range_band(R1, R2) end}; basic_type('bxor') -> {bin, fun(R1, R2) -> range_bxor(R1, R2) end}; basic_type('bnot') -> {unary, fun(R1) -> range_bnot(R1) end}; basic_type('bsl') -> {bin, fun(R1, R2) -> range_bsl(R1, R2) end}; basic_type('bsr') -> {bin, fun(R1, R2) -> range_bsr(R1, R2) end}; %% unsafe_* basic_type('unsafe_bor') -> {bin, fun(R1, R2) -> range_bor(R1, R2) end}; basic_type('unsafe_band') -> {bin, fun(R1, R2) -> range_band(R1, R2) end}; basic_type('unsafe_bxor') -> {bin, fun(R1, R2) -> range_bxor(R1, R2) end}; basic_type('unsafe_bnot') -> {unary, fun(R1) -> range_bnot(R1) end}; basic_type('unsafe_bsl') -> {bin, fun(R1, R2) -> range_bsl(R1, R2) end}; basic_type('unsafe_bsr') -> {bin, fun(R1, R2) -> range_bsr(R1, R2) end}; basic_type('unsafe_add') -> {bin, fun(R1, R2) -> range_add(R1, R2) end}; basic_type('unsafe_sub') -> {bin, fun(R1, R2) -> range_sub(R1, R2) end}; basic_type('extra_unsafe_add') -> {bin, fun(R1, R2) -> range_add(R1, R2) end}; basic_type('extra_unsafe_sub') -> {bin, fun(R1, R2) -> range_sub(R1, R2) end}; %% Binaries basic_type({hipe_bs_primop, _} = Primop) -> Primop; %% Unknown, other basic_type(call_fun) -> not_analysed; basic_type(clear_timeout) -> not_analysed; basic_type(redtest) -> not_analysed; basic_type(set_timeout) -> not_analysed; basic_type(#apply_N{}) -> not_analysed; basic_type(#closure_element{}) -> not_analysed; basic_type(#gc_test{}) -> not_analysed; %% Message handling basic_type(check_get_msg) -> not_analysed; basic_type(next_msg) -> not_analysed; basic_type(select_msg) -> not_analysed; basic_type(suspend_msg) -> not_analysed; %% Functions basic_type(enter_fun) -> not_analysed; basic_type(#mkfun{}) -> not_int; basic_type({_M,_F,_A} = MFA) -> {fcall, MFA}; %% Floats basic_type(conv_to_float) -> not_int; basic_type(fclearerror) -> not_analysed; basic_type(fcheckerror) -> not_analysed; basic_type(fnegate) -> not_int; basic_type(fp_add) -> not_int; basic_type(fp_div) -> not_int; basic_type(fp_mul) -> not_int; basic_type(fp_sub) -> not_int; basic_type(unsafe_tag_float) -> not_int; basic_type(unsafe_untag_float) -> not_int; %% Lists, tuples, records basic_type(cons) -> not_int; basic_type(mktuple) -> not_int; basic_type(unsafe_hd) -> not_analysed; basic_type(unsafe_tl) -> not_int; basic_type(#element{}) -> not_analysed; basic_type(#unsafe_element{}) -> not_analysed; basic_type(#unsafe_update_element{}) -> not_analysed. -spec analyse_bs_get_integer(integer(), integer(), boolean()) -> range_tuple(). analyse_bs_get_integer(Size, Flags, true) -> Signed = Flags band 4, if Signed =:= 0 -> Max = 1 bsl Size - 1, Min = 0; true -> Max = 1 bsl (Size-1) - 1, Min = -(1 bsl (Size-1)) end, {Min, Max}; analyse_bs_get_integer(Size, Flags, false) when is_integer(Size), is_integer(Flags) -> any_r(). %%--------------------------------------------------------------------------- %% Range operations %%--------------------------------------------------------------------------- %% Arithmetic -spec range_add(range(), range()) -> range(). range_add(Range1, Range2) -> NewMin = inf_add(range__min(Range1), range__min(Range2)), NewMax = inf_add(range__max(Range1), range__max(Range2)), Other = other(Range1) orelse other(Range2), range_init({NewMin, NewMax}, Other). -spec range_sub(range(), range()) -> range(). range_sub(Range1, Range2) -> Min_sub = inf_min([inf_inv(range__max(Range2)), inf_inv(range__min(Range2))]), Max_sub = inf_max([inf_inv(range__max(Range2)), inf_inv(range__min(Range2))]), NewMin = inf_add(range__min(Range1), Min_sub), NewMax = inf_add(range__max(Range1), Max_sub), Other = other(Range1) orelse other(Range2), range_init({NewMin, NewMax}, Other). -spec range_mult(range(), range()) -> range(). range_mult(#range{range=empty, other=true}, _Range2) -> range_init(empty, true); range_mult(_Range1, #range{range=empty, other=true}) -> range_init(empty, true); range_mult(Range1, Range2) -> Min1 = range__min(Range1), Min2 = range__min(Range2), Max1 = range__max(Range1), Max2 = range__max(Range2), GreaterMin1 = inf_greater_zero(Min1), GreaterMin2 = inf_greater_zero(Min2), GreaterMax1 = inf_greater_zero(Max1), GreaterMax2 = inf_greater_zero(Max2), Range = if GreaterMin1 -> if GreaterMin2 -> {inf_mult(Min1, Min2), inf_mult(Max1, Max2)}; GreaterMax2 -> {inf_mult(Min2, Max1), inf_mult(Max2, Max1)}; true -> {inf_mult(Min2, Max1), inf_mult(Max2, Min1)} end; %% Column 1 or 2 GreaterMin2 -> % Column 1 or 2 row 3 range(range_mult(Range2, Range1)); GreaterMax1 -> % Column 2 Row 1 or 2 if GreaterMax2 -> % Column 2 Row 2 NewMin = inf_min([inf_mult(Min2, Max1), inf_mult(Max2, Min1)]), NewMax = inf_max([inf_mult(Min2, Min1), inf_mult(Max2, Max1)]), {NewMin, NewMax}; true -> % Column 2 Row 1 {inf_mult(Min2, Max1), inf_mult(Min2, Min1)} end; GreaterMax2 -> % Column 1 Row 2 range(range_mult(Range2, Range1)); true -> % Column 1 Row 1 {inf_mult(Max1, Max2), inf_mult(Min2, Min1)} end, Other = other(Range1) orelse other(Range2), range_init(Range, Other). -spec extreme_divisors(range()) -> range_tuple(). extreme_divisors(#range{range={0,0}}) -> {0,0}; extreme_divisors(#range{range={0,Max}}) -> {1,Max}; extreme_divisors(#range{range={Min,0}}) -> {Min,-1}; extreme_divisors(#range{range={Min,Max}}) -> case inf_geq(Min, 0) of true -> {Min, Max}; false -> % Min < 0 case inf_geq(0, Max) of true -> {Min,Max}; % Max < 0 false -> {-1,1} % Max > 0 end end. -spec range_div(range(), range()) -> range(). %% this is div, not /. range_div(_, #range{range={0,0}}) -> range_init(empty, false); range_div(#range{range=empty}, _) -> range_init(empty, false); range_div(_, #range{range=empty}) -> range_init(empty, false); range_div(Range1, Den) -> Min1 = range__min(Range1), Max1 = range__max(Range1), {Min2, Max2} = extreme_divisors(Den), Min_max_list = [inf_div(Min1, Min2), inf_div(Min1, Max2), inf_div(Max1, Min2), inf_div(Max1, Max2)], range_init({inf_min(Min_max_list), inf_max(Min_max_list)}, false). -spec range_rem(range(), range()) -> range(). range_rem(Range1, Range2) -> %% Range1 desides the sign of the answer. Min1 = range__min(Range1), Max1 = range__max(Range1), Min2 = range__min(Range2), Max2 = range__max(Range2), Min1_geq_zero = inf_geq(Min1, 0), Max1_leq_zero = inf_geq(0, Max1), Max_range2 = inf_max([inf_abs(Min2), inf_abs(Max2)]), Max_range2_leq_zero = inf_geq(0, Max_range2), New_min = if Min1_geq_zero -> 0; Max_range2_leq_zero -> Max_range2; true -> inf_inv(Max_range2) end, New_max = if Max1_leq_zero -> 0; Max_range2_leq_zero -> inf_inv(Max_range2); true -> Max_range2 end, range_init({New_min, New_max}, false). %%--- Bit operations ---------------------------- -spec range_bsr(range(), range()) -> range(). range_bsr(Range1, Range2=#range{range={Min, Max}}) -> New_Range2 = range_init({inf_inv(Max), inf_inv(Min)}, other(Range2)), Ans = range_bsl(Range1, New_Range2), %% io:format("bsr res:~w~nInput:= ~w~n", [Ans, {Range1,Range2}]), Ans. -spec range_bsl(range(), range()) -> range(). range_bsl(Range1, Range2) -> Min1 = range__min(Range1), Min2 = range__min(Range2), Max1 = range__max(Range1), Max2 = range__max(Range2), Min1Geq0 = inf_geq(Min1, 0), Max1Less0 = not inf_geq(Max1, 0), MinMax = if Min1Geq0 -> {inf_bsl(Min1, Min2), inf_bsl(Max1, Max2)}; true -> if Max1Less0 -> {inf_bsl(Min1, Max2), inf_bsl(Max1, Min2)}; true -> {inf_bsl(Min1, Max2), inf_bsl(Max1, Max2)} end end, range_init(MinMax, false). -spec range_bnot(range()) -> range(). range_bnot(Range) -> Minus_one = range_init({-1,-1}, false), range_add(range_mult(Range, Minus_one), Minus_one). -spec width(range_rep() | inf_integer()) -> 'pos_inf' | non_neg_integer(). width({Min, Max}) -> inf_max([width(Min), width(Max)]); width(pos_inf) -> pos_inf; width(neg_inf) -> pos_inf; width(X) when is_integer(X), X >= 0 -> poswidth(X, 0); width(X) when is_integer(X), X < 0 -> negwidth(X, 0). -spec poswidth(non_neg_integer(), non_neg_integer()) -> non_neg_integer(). poswidth(X, N) -> case X < (1 bsl N) of true -> N; false -> poswidth(X, N+1) end. -spec negwidth(neg_integer(), non_neg_integer()) -> non_neg_integer(). negwidth(X, N) -> case X > (-1 bsl N) of true -> N; false -> negwidth(X, N+1) end. -spec range_band(range(), range()) -> range(). range_band(R1, R2) -> {_Min1, Max1} = MM1 = range(R1), {_Min2, Max2} = MM2 = range(R2), Width1 = width(MM1), Width2 = width(MM2), Range = case {classify_range(R1), classify_range(R2)} of {minus_minus, minus_minus} -> Width = inf_max([Width1, Width2]), {inf_bsl(-1, Width), -1}; {minus_minus, minus_plus} -> Width = inf_max([Width1, Width2]), {inf_bsl(-1, Width), Max2}; {minus_minus, plus_plus} -> {0, Max2}; {minus_plus, minus_minus} -> Width = inf_max([Width1, Width2]), {inf_bsl(-1, Width), Max1}; {minus_plus, minus_plus} -> Width = inf_max([Width1, Width2]), {inf_bsl(-1, Width), inf_max([Max1, Max2])}; {minus_plus, plus_plus} -> {0, Max2}; {plus_plus, minus_minus} -> {0, Max1}; {plus_plus, minus_plus} -> {0, Max1}; {plus_plus, plus_plus} -> {0, inf_min([Max1, Max2])} end, range_init(Range, false). -spec range_bor(range(), range()) -> range(). range_bor(R1, R2) -> {Min1, _Max1} = MM1 = range(R1), {Min2, _Max2} = MM2 = range(R2), Width1 = width(MM1), Width2 = width(MM2), Range = case {classify_range(R1), classify_range(R2)} of {minus_minus, minus_minus} -> {inf_max([Min1, Min2]), -1}; {minus_minus, minus_plus} -> {Min1, -1}; {minus_minus, plus_plus} -> {Min1, -1}; {minus_plus, minus_minus} -> {Min2, -1}; {minus_plus, minus_plus} -> Width = inf_max([Width1, Width2]), {inf_min([Min1, Min2]), inf_add(-1, inf_bsl(1, Width))}; {minus_plus, plus_plus} -> Width = inf_max([Width1, Width2]), {Min1, inf_add(-1, inf_bsl(1, Width))}; {plus_plus, minus_minus} -> {Min2, -1}; {plus_plus, minus_plus} -> Width = inf_max([Width1, Width2]), {Min2, inf_add(-1, inf_bsl(1, Width))}; {plus_plus, plus_plus} -> Width = inf_max([Width1, Width2]), {0, inf_add(-1, inf_bsl(1, Width))} end, range_init(Range, false). -spec classify_range(range()) -> 'minus_minus' | 'minus_plus' | 'plus_plus'. classify_range(Range) -> case range(Range) of {neg_inf, Number} when is_integer(Number), Number < 0 -> minus_minus; {neg_inf, Number} when is_integer(Number), Number >= 0 -> minus_plus; {Number, pos_inf} when is_integer(Number), Number < 0 -> minus_plus; {Number, pos_inf} when is_integer(Number), Number >= 0 -> plus_plus; {neg_inf, pos_inf} -> minus_plus; {Number1,Number2} when is_integer(Number1), is_integer(Number2) -> classify_int_range(Number1, Number2) end. -spec classify_int_range(integer(), integer()) -> 'minus_minus' | 'minus_plus' | 'plus_plus'. classify_int_range(Number1, _Number2) when Number1 >= 0 -> plus_plus; classify_int_range(_Number1, Number2) when Number2 < 0 -> minus_minus; classify_int_range(_Number1, _Number2) -> minus_plus. -spec range_bxor(range(), range()) -> range(). range_bxor(R1, R2) -> {Min1, Max1} = MM1 = range(R1), {Min2, Max2} = MM2 = range(R2), Width1 = width(MM1), Width2 = width(MM2), Range = case {classify_range(R1), classify_range(R2)} of {minus_minus, minus_minus} -> Width = inf_max([Width1, Width2]), {0, inf_add(-1, inf_bsl(1, Width))}; {minus_minus, minus_plus} -> MinWidth = inf_max([Width1, width({0,Max2})]), MaxWidth = inf_max([Width1, width({Min2,-1})]), {inf_bsl(-1, MinWidth), inf_add(-1, inf_bsl(1, MaxWidth))}; {minus_minus, plus_plus} -> Width = inf_max([Width1, Width2]), {inf_bsl(-1, Width), -1}; {minus_plus, minus_minus} -> MinWidth = inf_max([Width2,width({0,Max1})]), MaxWidth = inf_max([Width2,width({Min1,-1})]), {inf_bsl(-1, MinWidth), inf_add(-1, inf_bsl(1, MaxWidth))}; {minus_plus, minus_plus} -> Width = inf_max([Width1, Width2]), {inf_bsl(-1, Width), inf_add(-1, inf_bsl(1, Width))}; {minus_plus, plus_plus} -> MinWidth = inf_max([Width2,width({Min1,-1})]), MaxWidth = inf_max([Width2,width({0,Max1})]), {inf_bsl(-1, MinWidth), inf_add(-1, inf_bsl(1, MaxWidth))}; {plus_plus, minus_minus} -> Width = inf_max([Width1, Width2]), {inf_bsl(-1, Width), -1}; {plus_plus, minus_plus} -> MinWidth = inf_max([Width1,width({Min2,-1})]), MaxWidth = inf_max([Width1,width({0,Max2})]), {inf_bsl(-1, MinWidth), inf_add(-1, inf_bsl(1, MaxWidth))}; {plus_plus, plus_plus} -> Width = inf_max([Width1, Width2]), {0, inf_add(-1, inf_bsl(1, Width))} end, range_init(Range, false). %%--------------------------------------------------------------------------- %% Inf operations %%--------------------------------------------------------------------------- -spec inf_max([inf_integer(),...]) -> inf_integer(). inf_max([H|T]) -> lists:foldl(fun (Elem, Max) -> case inf_geq(Elem, Max) of false -> Max; true -> Elem end end, H, T). -spec inf_min([inf_integer(),...]) -> inf_integer(). inf_min([H|T]) -> lists:foldl(fun (Elem, Min) -> case inf_geq(Elem, Min) of true -> Min; false -> Elem end end, H, T). -spec inf_abs(inf_integer()) -> 'pos_inf' | integer(). inf_abs(pos_inf) -> pos_inf; inf_abs(neg_inf) -> pos_inf; inf_abs(Number) when is_integer(Number), (Number < 0) -> - Number; inf_abs(Number) when is_integer(Number) -> Number. -spec inf_add(inf_integer(), inf_integer()) -> inf_integer(). inf_add(pos_inf, _Number) -> pos_inf; inf_add(neg_inf, _Number) -> neg_inf; inf_add(_Number, pos_inf) -> pos_inf; inf_add(_Number, neg_inf) -> neg_inf; inf_add(Number1, Number2) when is_integer(Number1), is_integer(Number2) -> Number1 + Number2. -spec inf_inv(inf_integer()) -> inf_integer(). inf_inv(pos_inf) -> neg_inf; inf_inv(neg_inf) -> pos_inf; inf_inv(Number) -> -Number. -spec inf_geq(inf_integer(), inf_integer()) -> boolean(). inf_geq(pos_inf, _) -> true; inf_geq(_, pos_inf) -> false; inf_geq(_, neg_inf) -> true; inf_geq(neg_inf, _) -> false; inf_geq(A, B) -> A >= B. -spec inf_greater_zero(inf_integer()) -> boolean(). inf_greater_zero(pos_inf) -> true; inf_greater_zero(neg_inf) -> false; inf_greater_zero(Number) when is_integer(Number), Number >= 0 -> true; inf_greater_zero(Number) when is_integer(Number), Number < 0 -> false. -spec inf_div(inf_integer(), inf_integer()) -> inf_integer(). inf_div(Number, 0) -> Greater = inf_greater_zero(Number), if Greater -> pos_inf; true -> neg_inf end; inf_div(pos_inf, Number) -> Greater = inf_greater_zero(Number), if Greater -> pos_inf; true -> neg_inf end; inf_div(neg_inf, Number) -> Greater = inf_greater_zero(Number), if Greater -> neg_inf; true -> pos_inf end; inf_div(Number, pos_inf) -> Greater = inf_greater_zero(Number), if Greater -> pos_inf; true -> neg_inf end; inf_div(Number, neg_inf) -> Greater = inf_greater_zero(Number), if Greater -> neg_inf; true -> pos_inf end; inf_div(Number1, Number2) -> Number1 div Number2. -spec inf_mult(inf_integer(), inf_integer()) -> inf_integer(). inf_mult(neg_inf, Number) -> Greater = inf_greater_zero(Number), if Greater -> neg_inf; true -> pos_inf end; inf_mult(pos_inf, Number) -> Greater = inf_greater_zero(Number), if Greater -> pos_inf; true -> neg_inf end; inf_mult(Number, pos_inf) -> inf_mult(pos_inf, Number); inf_mult(Number, neg_inf) -> inf_mult(neg_inf, Number); inf_mult(Number1, Number2) -> Number1 * Number2. -spec inf_bsl(inf_integer(), inf_integer()) -> inf_integer(). inf_bsl(pos_inf, _) -> pos_inf; inf_bsl(neg_inf, _) -> neg_inf; inf_bsl(Number, pos_inf) when is_integer(Number), Number >= 0 -> pos_inf; inf_bsl(_, pos_inf) -> neg_inf; inf_bsl(Number, neg_inf) when is_integer(Number), Number >= 0 -> 0; inf_bsl(_Number, neg_inf) -> -1; inf_bsl(Number1, Number2) when is_integer(Number1), is_integer(Number2) -> %% We can not shift left with a number which is not a fixnum. We %% don't have enough memory. Bits = ?BITS, if Number2 > (Bits bsl 1) -> inf_bsl(Number1, pos_inf); Number2 < (-Bits bsl 1) -> inf_bsl(Number1, neg_inf); true -> Number1 bsl Number2 end. %% State -spec state__init(cfg(), data()) -> #state{}. state__init(Cfg, {MFA, ArgsFun, CallFun, FinalFun}) -> Start = hipe_icode_cfg:start_label(Cfg), Params = hipe_icode_cfg:params(Cfg), Ranges = ArgsFun(MFA, Cfg), %% io:format("MFA: ~w~nRanges: ~w~n", [MFA, Ranges]), Liveness = hipe_icode_ssa:ssa_liveness__analyze(hipe_icode_type:unannotate_cfg(Cfg)), case lists:any(fun range__is_none/1, Ranges) of true -> FinalFun(MFA, [none_type()]), throw(no_input); false -> NewParams = lists:zipwith(fun update_info/2, Params, Ranges), NewCfg = hipe_icode_cfg:params_update(Cfg, NewParams), Info = enter_defines(NewParams, gb_trees:empty()), InfoMap = gb_trees:insert({Start, in}, Info, gb_trees:empty()), #state{info_map=InfoMap, cfg=NewCfg, liveness=Liveness, ret_type=none_type(), lookup_fun=CallFun, result_action=FinalFun} end. -spec state__cfg(#state{}) -> cfg(). state__cfg(#state{cfg=Cfg}) -> Cfg. -spec state__bb(#state{}, label()) -> bb(). state__bb(#state{cfg=Cfg}, Label) -> BB = hipe_icode_cfg:bb(Cfg, Label), true = hipe_bb:is_bb(BB), % Just an assert BB. -spec state__bb_add(#state{}, label(), bb()) -> #state{}. state__bb_add(S=#state{cfg=Cfg}, Label, BB) -> NewCfg = hipe_icode_cfg:bb_add(Cfg, Label, BB), S#state{cfg=NewCfg}. state__lookup_fun(#state{lookup_fun=LF}) -> LF. state__result_action(#state{result_action=RA}) -> RA. state__ret_type(#state{ret_type=RT}) -> RT. state__ret_type_update(#state{ret_type=RT} = State, NewType) -> TotType = sup(RT, NewType), State#state{ret_type=TotType}. state__info_in(S, Label) -> state__info(S, {Label, in}). state__info(#state{info_map=IM}, Key) -> gb_trees:get(Key, IM). state__update_info(State, LabelInfo, Rewrite) -> update_info(LabelInfo, State, [], Rewrite). update_info([{Label,InfoIn}|Rest], State, LabelAcc, Rewrite) -> case state__info_in_update(State, Label, InfoIn) of fixpoint -> if Rewrite -> update_info(Rest, State, [Label|LabelAcc], Rewrite); true -> update_info(Rest, State, LabelAcc, Rewrite) end; NewState -> update_info(Rest, NewState, [Label|LabelAcc], Rewrite) end; update_info([], State, LabelAcc, _Rewrite) -> {State, LabelAcc}. state__info_in_update(S=#state{info_map=IM,liveness=Liveness}, Label, Info) -> LabelIn = {Label, in}, case gb_trees:lookup(LabelIn, IM) of none -> LiveIn = hipe_icode_ssa:ssa_liveness__livein(Liveness, Label), NamesLiveIn = [hipe_icode:var_name(Var) || Var <- LiveIn, hipe_icode:is_var(Var)], OldInfo = gb_trees:empty(), case join_info_in(NamesLiveIn, OldInfo, Info) of fixpoint -> S#state{info_map=gb_trees:insert(LabelIn, OldInfo, IM)}; NewInfo -> S#state{info_map=gb_trees:enter(LabelIn, NewInfo, IM)} end; {value, OldInfo} -> OldVars = gb_trees:keys(OldInfo), case join_info_in(OldVars, OldInfo, Info) of fixpoint -> fixpoint; NewInfo -> S#state{info_map=gb_trees:update(LabelIn, NewInfo, IM)} end end. join_info_in(Vars, OldInfo, NewInfo) -> case join_info_in(Vars, OldInfo, NewInfo, gb_trees:empty(), false) of {Res, true} -> Res; {_, false} -> fixpoint end. join_info_in([Var|Left], Info1, Info2, Acc, Changed) -> Type1 = gb_trees:lookup(Var, Info1), Type2 = gb_trees:lookup(Var, Info2), case {Type1, Type2} of {none, none} -> NewTree = gb_trees:insert(Var, none_type(), Acc), join_info_in(Left, Info1, Info2, NewTree, true); {none, {value, Val}} -> NewTree = gb_trees:insert(Var, Val, Acc), join_info_in(Left, Info1, Info2, NewTree, true); {{value, Val}, none} -> NewTree = gb_trees:insert(Var, Val, Acc), join_info_in(Left, Info1, Info2, NewTree, Changed); {{value, Val}, {value, Val}} -> NewTree = gb_trees:insert(Var, Val, Acc), join_info_in(Left, Info1, Info2, NewTree, Changed); {{value, Val1}, {value, Val2}} -> NewVal = case sup(Val1, Val2) of Val1 -> NewChanged = Changed, Val1; Val -> NewChanged = true, Val end, NewTree = gb_trees:insert(Var, NewVal, Acc), join_info_in(Left, Info1, Info2, NewTree, NewChanged) end; join_info_in([], _Info1, _Info2, Acc, NewChanged) -> {Acc, NewChanged}. enter_defines([Def|Rest], Info) -> enter_defines(Rest, enter_define(Def, Info)); enter_defines([], Info) -> Info. enter_define({PossibleVar, Range = #range{}}, Info) -> case hipe_icode:is_var(PossibleVar) of true -> gb_trees:enter(hipe_icode:var_name(PossibleVar), Range, Info); false -> Info end; enter_define(PossibleVar, Info) -> case hipe_icode:is_var(PossibleVar) of true -> case hipe_icode:variable_annotation(PossibleVar) of {range_anno, #ann{range=Range}, _} -> gb_trees:enter(hipe_icode:var_name(PossibleVar), Range, Info); _ -> Info end; false -> Info end. enter_vals(Ins, Info) -> NewInfo = enter_defines(hipe_icode:args(Ins), Info), enter_defines(hipe_icode:defines(Ins), NewInfo). lookup(PossibleVar, Info) -> case hipe_icode:is_var(PossibleVar) of true -> case gb_trees:lookup(hipe_icode:var_name(PossibleVar), Info) of none -> none_type(); {value, Val} -> Val end; false -> none_type() end. %% _________________________________________________________________ %% %% The worklist. %% init_work(State) -> %% Labels = hipe_icode_cfg:reverse_postorder(state__cfg(State)), Labels = [hipe_icode_cfg:start_label(state__cfg(State))], {Labels, [], sets:from_list(Labels)}. get_work({[Label|Left], List, Set}) -> NewWork = {Left, List, sets:del_element(Label, Set)}, {Label, NewWork}; get_work({[], [], _Set}) -> fixpoint; get_work({[], List, Set}) -> get_work({lists:reverse(List), [], Set}). add_work(Work = {List1, List2, Set}, [Label|Left]) -> case sets:is_element(Label, Set) of true -> add_work(Work, Left); false -> %% io:format("Adding work: ~w\n", [Label]), add_work({List1, [Label|List2], sets:add_element(Label, Set)}, Left) end; add_work(Work, []) -> Work. convert_cfg_to_types(Cfg) -> Lbls = hipe_icode_cfg:reverse_postorder(Cfg), lists:foldl(fun convert_lbl_to_type/2, Cfg, Lbls). convert_lbl_to_type(Lbl, Cfg) -> BB = hipe_icode_cfg:bb(Cfg, Lbl), Code = hipe_bb:code(BB), NewCode = [convert_instr_to_type(I) || I <- Code], hipe_icode_cfg:bb_add(Cfg, Lbl, hipe_bb:mk_bb(NewCode)). convert_instr_to_type(I) -> Uses = hipe_icode:uses(I), UseSubstList = [{Use, convert_to_types(Use)} || Use <- Uses, hipe_icode:is_annotated_variable(Use)], NewI = hipe_icode:subst_uses(UseSubstList, I), Defs = hipe_icode:defines(NewI), DefSubstList = [{Def, convert_to_types(Def)} || Def <- Defs, hipe_icode:is_annotated_variable(Def)], hipe_icode:subst_defines(DefSubstList, NewI). convert_to_types(VarOrReg) -> Annotation = case hipe_icode:variable_annotation(VarOrReg) of {range_anno, Ann, _} -> {type_anno, convert_ann_to_types(Ann), fun erl_types:t_to_string/1}; {type_anno, _, _} = TypeAnn -> TypeAnn end, hipe_icode:annotate_variable(VarOrReg, Annotation). convert_ann_to_types(#ann{range=#range{range={Min,Max}, other=false}}) -> t_from_range_unsafe(Min, Max); convert_ann_to_types(#ann{range=#range{range=empty, other=false}}) -> t_none(); convert_ann_to_types(#ann{range=#range{other=true}, type=Type}) -> Type. %%===================================================================== %% Icode Coordinator Callbacks %%===================================================================== -spec replace_nones([range()]) -> [range()]. replace_nones(Args) -> [replace_none(Arg) || Arg <- Args]. replace_none(Arg) -> case range__is_none(Arg) of true -> any_type(); false -> Arg end. -spec update__info([range()], [range()]) -> {boolean(), [ann()]}. update__info(NewRanges, OldRanges) -> SupFun = fun (Ann, Range) -> join_info(Ann, Range, fun safe_widen/3) end, EqFun = fun (X, Y) -> X =:= Y end, ResRanges = lists:zipwith(SupFun, OldRanges, NewRanges), Change = lists:zipwith(EqFun, ResRanges, OldRanges), {lists:all(fun (X) -> X end, Change), ResRanges}. -spec new__info([range()]) -> [ann()]. new__info(NewRanges) -> [#ann{range=Range,count=1,type=t_any()} || Range <- NewRanges]. -spec return__info([ann()]) -> [range()]. return__info(Ranges) -> [Range || #ann{range=Range} <- Ranges]. -spec return_none() -> [range(),...]. return_none() -> [none_type()]. -spec return_none_args(cfg(), mfa()) -> [range()]. return_none_args(Cfg, {_M,_F,A}) -> NoArgs = case hipe_icode_cfg:is_closure(Cfg) of true -> hipe_icode_cfg:closure_arity(Cfg) + 1; false -> A end, lists:duplicate(NoArgs, none_type()). -spec return_any_args(cfg(), mfa()) -> [range()]. return_any_args(Cfg, {_M,_F,A}) -> NoArgs = case hipe_icode_cfg:is_closure(Cfg) of true -> hipe_icode_cfg:closure_arity(Cfg) + 1; false -> A end, lists:duplicate(NoArgs, any_type()). %%===================================================================== next_up_limit(X) when is_integer(X), X < 0 -> 0; next_up_limit(X) when is_integer(X), X < 255 -> 255; next_up_limit(X) when is_integer(X), X < 16#10ffff -> 16#10ffff; next_up_limit(X) when is_integer(X), X < 16#7ffffff -> 16#7ffffff; next_up_limit(X) when is_integer(X), X < 16#7fffffff -> 16#7fffffff; next_up_limit(X) when is_integer(X), X < 16#ffffffff -> 16#ffffffff; next_up_limit(X) when is_integer(X), X < 16#fffffffffff -> 16#fffffffffff; next_up_limit(X) when is_integer(X), X < 16#7fffffffffffffff -> 16#7fffffffffffffff; next_up_limit(_X) -> pos_inf. next_down_limit(X) when is_integer(X), X > 0 -> 0; next_down_limit(X) when is_integer(X), X > -256 -> -256; next_down_limit(X) when is_integer(X), X > -16#10ffff -> -16#10ffff; next_down_limit(X) when is_integer(X), X > -16#8000000 -> -16#8000000; next_down_limit(X) when is_integer(X), X > -16#80000000 -> -16#80000000; next_down_limit(X) when is_integer(X), X > -16#800000000000000 -> -16#800000000000000; next_down_limit(_X) -> neg_inf.