%% %% %CopyrightBegin% %% %% Copyright Ericsson AB 2018. All Rights Reserved. %% %% 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. %% %% %CopyrightEnd% %% %% Purpose: Convert the Kernel Erlang format to the SSA format. -module(beam_kernel_to_ssa). %% The main interface. -export([module/2]). -import(lists, [append/1,duplicate/2,flatmap/2,foldl/3, keysort/2,mapfoldl/3,map/2,member/2, reverse/1,reverse/2,sort/1]). -include("v3_kernel.hrl"). -include("beam_ssa.hrl"). -type label() :: beam_ssa:label(). %% Main codegen structure. -record(cg, {lcount=1 :: label(), %Label counter bfail=1 :: label(), catch_label=none :: 'none' | label(), vars=#{} :: map(), %Defined variables. break=0 :: label(), %Break label recv=0 :: label(), %Receive label ultimate_failure=0 :: label() %Label for ultimate match failure. }). %% Internal records. -record(cg_break, {args :: [beam_ssa:value()], phi :: label() }). -record(cg_phi, {vars :: [beam_ssa:b_var()] }). -record(cg_unreachable, {}). -spec module(#k_mdef{}, [compile:option()]) -> {'ok',#b_module{}}. module(#k_mdef{name=Mod,exports=Es,attributes=Attr,body=Forms}, _Opts) -> Body = functions(Forms, Mod), Module = #b_module{name=Mod,exports=Es,attributes=Attr,body=Body}, {ok,Module}. functions(Forms, Mod) -> [function(F, Mod) || F <- Forms]. function(#k_fdef{anno=Anno0,func=Name,arity=Arity, vars=As0,body=Kb}, Mod) -> try #k_match{} = Kb, %Assertion. %% Generate the SSA form immediate format. St0 = #cg{}, {As,St1} = new_ssa_vars(As0, St0), {Asm,St} = cg_fun(Kb, St1), Anno1 = line_anno(Anno0), Anno = Anno1#{func_info=>{Mod,Name,Arity}}, #b_function{anno=Anno,args=As,bs=Asm,cnt=St#cg.lcount} catch Class:Error:Stack -> io:fwrite("Function: ~w/~w\n", [Name,Arity]), erlang:raise(Class, Error, Stack) end. %% cg_fun([Lkexpr], [HeadVar], State) -> {[Ainstr],State} cg_fun(Ke, St0) -> {UltimateFail,FailIs,St1} = make_failure(badarg, St0), ?EXCEPTION_BLOCK = UltimateFail, %Assertion. St2 = St1#cg{bfail=UltimateFail,ultimate_failure=UltimateFail}, {B,St} = cg(Ke, St2), Asm = [{label,0}|B++FailIs], finalize(Asm, St). make_failure(Reason, St0) -> {Lbl,St1} = new_label(St0), {Dst,St} = new_ssa_var('@ssa_ret', St1), Is = [{label,Lbl}, #b_set{op=call,dst=Dst, args=[#b_remote{mod=#b_literal{val=erlang}, name=#b_literal{val=error}, arity=1}, #b_literal{val=Reason}]}, #b_ret{arg=Dst}], {Lbl,Is,St}. %% cg(Lkexpr, State) -> {[Ainstr],State}. %% Generate code for a kexpr. cg(#k_match{body=M,ret=Rs}, St) -> do_match_cg(M, Rs, St); cg(#k_guard_match{body=M,ret=Rs}, St) -> do_match_cg(M, Rs, St); cg(#k_seq{arg=Arg,body=Body}, St0) -> {ArgIs,St1} = cg(Arg, St0), {BodyIs,St} = cg(Body, St1), {ArgIs++BodyIs,St}; cg(#k_call{anno=Le,op=Func,args=As,ret=Rs}, St) -> call_cg(Func, As, Rs, Le, St); cg(#k_enter{anno=Le,op=Func,args=As}, St) -> enter_cg(Func, As, Le, St); cg(#k_bif{anno=Le}=Bif, St) -> bif_cg(Bif, Le, St); cg(#k_try{arg=Ta,vars=Vs,body=Tb,evars=Evs,handler=Th,ret=Rs}, St) -> try_cg(Ta, Vs, Tb, Evs, Th, Rs, St); cg(#k_try_enter{arg=Ta,vars=Vs,body=Tb,evars=Evs,handler=Th}, St) -> try_enter_cg(Ta, Vs, Tb, Evs, Th, St); cg(#k_catch{body=Cb,ret=[R]}, St) -> do_catch_cg(Cb, R, St); cg(#k_receive{anno=Le,timeout=Te,var=Rvar,body=Rm,action=Tes,ret=Rs}, St) -> recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, St); cg(#k_receive_next{}, #cg{recv=Recv}=St) -> Is = [#b_set{op=recv_next},make_uncond_branch(Recv)], {Is,St}; cg(#k_receive_accept{}, St) -> Remove = #b_set{op=remove_message}, {[Remove],St}; cg(#k_put{anno=Le,arg=Con,ret=Var}, St) -> put_cg(Var, Con, Le, St); cg(#k_return{args=[Ret0]}, St) -> Ret = ssa_arg(Ret0, St), {[#b_ret{arg=Ret}],St}; cg(#k_break{args=Bs}, #cg{break=Br}=St) -> Args = ssa_args(Bs, St), {[#cg_break{args=Args,phi=Br}],St}; cg(#k_guard_break{args=Bs}, St) -> cg(#k_break{args=Bs}, St). %% match_cg(Matc, [Ret], State) -> {[Ainstr],State}. %% Generate code for a match. do_match_cg(M, Rs, St0) -> {B,St1} = new_label(St0), {Mis,St2} = match_cg(M, St1#cg.bfail, St1#cg{break=B}), {BreakVars,St} = new_ssa_vars(Rs, St2), {Mis ++ [{label,B},#cg_phi{vars=BreakVars}], St#cg{bfail=St0#cg.bfail,break=St1#cg.break}}. %% match_cg(Match, Fail, State) -> {[Ainstr],State}. %% Generate code for a match tree. match_cg(#k_alt{first=F,then=S}, Fail, St0) -> {Tf,St1} = new_label(St0), {Fis,St2} = match_cg(F, Tf, St1), {Sis,St3} = match_cg(S, Fail, St2), {Fis ++ [{label,Tf}] ++ Sis,St3}; match_cg(#k_select{var=#k_var{}=V,types=Scs}, Fail, St) -> match_fmf(fun (S, F, Sta) -> select_cg(S, V, F, Fail, Sta) end, Fail, St, Scs); match_cg(#k_guard{clauses=Gcs}, Fail, St) -> match_fmf(fun (G, F, Sta) -> guard_clause_cg(G, F, Sta) end, Fail, St, Gcs); match_cg(Ke, _Fail, St0) -> cg(Ke, St0). %% select_cg(Sclause, V, TypeFail, ValueFail, State) -> {Is,State}. %% Selecting type and value needs two failure labels, TypeFail is the %% label to jump to of the next type test when this type fails, and %% ValueFail is the label when this type is correct but the value is %% wrong. These are different as in the second case there is no need %% to try the next type, it will always fail. select_cg(#k_type_clause{type=k_binary,values=[S]}, Var, Tf, Vf, St) -> select_binary(S, Var, Tf, Vf, St); select_cg(#k_type_clause{type=k_bin_seg,values=Vs}, Var, Tf, _Vf, St) -> select_bin_segs(Vs, Var, Tf, St); select_cg(#k_type_clause{type=k_bin_int,values=Vs}, Var, Tf, _Vf, St) -> select_bin_segs(Vs, Var, Tf, St); select_cg(#k_type_clause{type=k_bin_end,values=[S]}, Var, Tf, _Vf, St) -> select_bin_end(S, Var, Tf, St); select_cg(#k_type_clause{type=k_map,values=Vs}, Var, Tf, Vf, St) -> select_map(Vs, Var, Tf, Vf, St); select_cg(#k_type_clause{type=k_cons,values=[S]}, Var, Tf, Vf, St) -> select_cons(S, Var, Tf, Vf, St); select_cg(#k_type_clause{type=k_nil,values=[S]}, Var, Tf, Vf, St) -> select_nil(S, Var, Tf, Vf, St); select_cg(#k_type_clause{type=k_literal,values=Vs}, Var, Tf, Vf, St) -> select_literal(Vs, Var, Tf, Vf, St); select_cg(#k_type_clause{type=Type,values=Scs}, Var, Tf, Vf, St0) -> {Vis,St1} = mapfoldl(fun (S, Sta) -> {Val,Is,Stb} = select_val(S, Var, Vf, Sta), {{Is,[Val]},Stb} end, St0, Scs), OptVls = combine(lists:sort(combine(Vis))), {Vls,Sis,St2} = select_labels(OptVls, St1, [], []), Arg = ssa_arg(Var, St2), {Is,St} = select_val_cg(Type, Arg, Vls, Tf, Vf, Sis, St2), {Is,St}. select_val_cg(k_tuple, Tuple, Vls, Tf, Vf, Sis, St0) -> {Is0,St1} = make_cond_branch({bif,is_tuple}, [Tuple], Tf, St0), {Arity,St2} = new_ssa_var('@ssa_arity', St1), GetArity = #b_set{op={bif,tuple_size},dst=Arity,args=[Tuple]}, {Is,St} = select_val_cg(k_int, Arity, Vls, Vf, Vf, Sis, St2), {Is0++[GetArity]++Is,St}; select_val_cg(Type, R, Vls, Tf, Vf, Sis, St0) -> {TypeIs,St1} = if Tf =:= Vf -> %% The type and value failure labels are the same; %% we don't need a type test. {[],St0}; true -> %% Different labels for type failure and %% label failure; we need a type test. Test = select_type_test(Type), make_cond_branch(Test, [R], Tf, St0) end, case Vls of [{Val,Succ}] -> {Is,St} = make_cond({bif,'=:='}, [R,Val], Vf, Succ, St1), {TypeIs++Is++Sis,St}; [_|_] -> {TypeIs++[#b_switch{arg=R,fail=Vf,list=Vls}|Sis],St1} end. select_type_test(k_int) -> {bif,is_integer}; select_type_test(k_atom) -> {bif,is_atom}; select_type_test(k_float) -> {bif,is_float}. combine([{Is,Vs1},{Is,Vs2}|Vis]) -> combine([{Is,Vs1 ++ Vs2}|Vis]); combine([V|Vis]) -> [V|combine(Vis)]; combine([]) -> []. select_labels([{Is,Vs}|Vis], St0, Vls, Sis) -> {Lbl,St1} = new_label(St0), select_labels(Vis, St1, add_vls(Vs, Lbl, Vls), [[{label,Lbl}|Is]|Sis]); select_labels([], St, Vls, Sis) -> {Vls,append(Sis),St}. add_vls([V|Vs], Lbl, Acc) -> add_vls(Vs, Lbl, [{#b_literal{val=V},Lbl}|Acc]); add_vls([], _, Acc) -> Acc. select_literal(S, V, Tf, Vf, St) -> Src = ssa_arg(V, St), F = fun(ValClause, Fail, St0) -> {Val,ValIs,St1} = select_val(ValClause, V, Vf, St0), Args = [Src,#b_literal{val=Val}], {Is,St2} = make_cond_branch({bif,'=:='}, Args, Fail, St1), {Is++ValIs,St2} end, match_fmf(F, Tf, St, S). select_cons(#k_val_clause{val=#k_cons{hd=Hd,tl=Tl},body=B}, V, Tf, Vf, St0) -> Es = [Hd,Tl], {Eis,St1} = select_extract_cons(V, Es, St0), {Bis,St2} = match_cg(B, Vf, St1), Src = ssa_arg(V, St2), {Is,St} = make_cond_branch(is_nonempty_list, [Src], Tf, St2), {Is ++ Eis ++ Bis,St}. select_nil(#k_val_clause{val=#k_nil{},body=B}, V, Tf, Vf, St0) -> {Bis,St1} = match_cg(B, Vf, St0), Src = ssa_arg(V, St1), {Is,St} = make_cond_branch({bif,'=:='}, [Src,#b_literal{val=[]}], Tf, St1), {Is ++ Bis,St}. select_binary(#k_val_clause{val=#k_binary{segs=#k_var{name=Ctx0}},body=B}, #k_var{}=Src, Tf, Vf, St0) -> {Ctx,St1} = new_ssa_var(Ctx0, St0), {Bis0,St2} = match_cg(B, Vf, St1), {TestIs,St} = make_succeeded(Ctx, {guard, Tf}, St2), Bis1 = [#b_set{op=bs_start_match,dst=Ctx, args=[ssa_arg(Src, St)]}] ++ TestIs ++ Bis0, Bis = finish_bs_matching(Bis1), {Bis,St}. finish_bs_matching([#b_set{op=bs_match, args=[#b_literal{val=string},Ctx,#b_literal{val=BinList}]}=Set|Is]) when is_list(BinList) -> I = Set#b_set{args=[#b_literal{val=string},Ctx, #b_literal{val=list_to_bitstring(BinList)}]}, finish_bs_matching([I|Is]); finish_bs_matching([I|Is]) -> [I|finish_bs_matching(Is)]; finish_bs_matching([]) -> []. make_cond(Cond, Args, Fail, Succ, St0) -> {Bool,St} = new_ssa_var('@ssa_bool', St0), Bif = #b_set{op=Cond,dst=Bool,args=Args}, Br = #b_br{bool=Bool,succ=Succ,fail=Fail}, {[Bif,Br],St}. make_cond_branch(Cond, Args, Fail, St0) -> {Bool,St1} = new_ssa_var('@ssa_bool', St0), {Succ,St} = new_label(St1), Bif = #b_set{op=Cond,dst=Bool,args=Args}, Br = #b_br{bool=Bool,succ=Succ,fail=Fail}, {[Bif,Br,{label,Succ}],St}. make_uncond_branch(Fail) -> #b_br{bool=#b_literal{val=true},succ=Fail,fail=Fail}. %% %% The 'succeeded' instruction needs special treatment in catch blocks to %% prevent the checked operation from being optimized away if a later pass %% determines that it always fails. %% make_succeeded(Var, {in_catch, CatchLbl}, St0) -> {Bool, St1} = new_ssa_var('@ssa_bool', St0), {Succ, St2} = new_label(St1), {Fail, St} = new_label(St2), Check = [#b_set{op=succeeded,dst=Bool,args=[Var]}, #b_br{bool=Bool,succ=Succ,fail=Fail}], %% Add a dummy block that references the checked variable, ensuring it %% stays alive and that it won't be merged with the landing pad. Trampoline = [{label,Fail}, #b_set{op=exception_trampoline,args=[Var]}, make_uncond_branch(CatchLbl)], {Check ++ Trampoline ++ [{label,Succ}], St}; make_succeeded(Var, {no_catch, Fail}, St) -> %% Ultimate failure raises an exception, so we must treat it as if it were %% in a catch to keep it from being optimized out. #cg{ultimate_failure=Fail} = St, %Assertion make_succeeded(Var, {in_catch, Fail}, St); make_succeeded(Var, {guard, Fail}, St) -> make_cond_branch(succeeded, [Var], Fail, St). %% Instructions for selection of binary segments. select_bin_segs(Scs, Ivar, Tf, St) -> match_fmf(fun(S, Fail, Sta) -> select_bin_seg(S, Ivar, Fail, Sta) end, Tf, St, Scs). select_bin_seg(#k_val_clause{val=#k_bin_seg{size=Size,unit=U,type=T, seg=Seg,flags=Fs,next=Next}, body=B,anno=Anno}, #k_var{}=Src, Fail, St0) -> LineAnno = line_anno(Anno), Ctx = get_context(Src, St0), {Mis,St1} = select_extract_bin(Next, Size, U, T, Fs, Fail, Ctx, LineAnno, St0), {Extracted,St2} = new_ssa_var(Seg#k_var.name, St1), {Bis,St} = match_cg(B, Fail, St2), BsGet = #b_set{op=bs_extract,dst=Extracted,args=[ssa_arg(Next, St)]}, Is = Mis ++ [BsGet] ++ Bis, {Is,St}; select_bin_seg(#k_val_clause{val=#k_bin_int{size=Sz,unit=U,flags=Fs, val=Val,next=Next}, body=B}, #k_var{}=Src, Fail, St0) -> Ctx = get_context(Src, St0), {Mis,St1} = select_extract_int(Next, Val, Sz, U, Fs, Fail, Ctx, St0), {Bis,St} = match_cg(B, Fail, St1), Is = case Mis ++ Bis of [#b_set{op=bs_match,args=[#b_literal{val=string},OtherCtx1,Bin1]}, #b_set{op=succeeded,dst=Bool1}, #b_br{bool=Bool1,succ=Succ,fail=Fail}, {label,Succ}, #b_set{op=bs_match,dst=Dst,args=[#b_literal{val=string},_OtherCtx2,Bin2]}| [#b_set{op=succeeded,dst=Bool2}, #b_br{bool=Bool2,fail=Fail}|_]=Is0] -> %% We used to do this optimization later, but it %% turns out that in huge functions with many %% string matching instructions, it's a huge win %% to do the combination now. To avoid copying the %% binary data again and again, we'll combine bitstrings %% in a list and convert all of it to a bitstring later. {#b_literal{val=B1},#b_literal{val=B2}} = {Bin1,Bin2}, Bin = #b_literal{val=[B1,B2]}, Set = #b_set{op=bs_match,dst=Dst,args=[#b_literal{val=string},OtherCtx1,Bin]}, [Set|Is0]; Is0 -> Is0 end, {Is,St}. get_context(#k_var{}=Var, St) -> ssa_arg(Var, St). select_bin_end(#k_val_clause{val=#k_bin_end{},body=B}, Src, Tf, St0) -> Ctx = get_context(Src, St0), {Bis,St1} = match_cg(B, Tf, St0), {TestIs,St} = make_cond_branch(bs_test_tail, [Ctx,#b_literal{val=0}], Tf, St1), Is = TestIs++Bis, {Is,St}. select_extract_bin(#k_var{name=Hd}, Size0, Unit, Type, Flags, Vf, Ctx, Anno, St0) -> {Dst,St1} = new_ssa_var(Hd, St0), Size = ssa_arg(Size0, St0), build_bs_instr(Anno, Type, Vf, Ctx, Size, Unit, Flags, Dst, St1). select_extract_int(#k_var{name=Tl}, 0, #k_int{val=0}, _U, _Fs, _Vf, Ctx, St0) -> St = set_ssa_var(Tl, Ctx, St0), {[],St}; select_extract_int(#k_var{name=Tl}, Val, #k_int{val=Sz}, U, Fs, Vf, Ctx, St0) -> {Dst,St1} = new_ssa_var(Tl, St0), Bits = U*Sz, Bin = case member(big, Fs) of true -> <>; false -> true = member(little, Fs), %Assertion. <> end, Bits = bit_size(Bin), %Assertion. {TestIs,St} = make_succeeded(Dst, {guard, Vf}, St1), Set = #b_set{op=bs_match,dst=Dst, args=[#b_literal{val=string},Ctx,#b_literal{val=Bin}]}, {[Set|TestIs],St}. build_bs_instr(Anno, Type, Fail, Ctx, Size, Unit0, Flags0, Dst, St0) -> Unit = #b_literal{val=Unit0}, Flags = #b_literal{val=Flags0}, NeedSize = bs_need_size(Type), TypeArg = #b_literal{val=Type}, Get = case NeedSize of true -> #b_set{anno=Anno,op=bs_match,dst=Dst, args=[TypeArg,Ctx,Flags,Size,Unit]}; false -> #b_set{anno=Anno,op=bs_match,dst=Dst, args=[TypeArg,Ctx,Flags]} end, {Is,St} = make_succeeded(Dst, {guard, Fail}, St0), {[Get|Is],St}. select_val(#k_val_clause{val=#k_tuple{es=Es},body=B}, V, Vf, St0) -> #k{us=Used} = k_get_anno(B), {Eis,St1} = select_extract_tuple(V, Es, Used, St0), {Bis,St2} = match_cg(B, Vf, St1), {length(Es),Eis ++ Bis,St2}; select_val(#k_val_clause{val=Val0,body=B}, _V, Vf, St0) -> Val = case Val0 of #k_atom{val=Lit} -> Lit; #k_float{val=Lit} -> Lit; #k_int{val=Lit} -> Lit; #k_literal{val=Lit} -> Lit end, {Bis,St1} = match_cg(B, Vf, St0), {Val,Bis,St1}. %% select_extract_tuple(Src, [V], State) -> {[E],State}. %% Extract tuple elements, but only if they are actually used. %% %% Not extracting tuple elements that are not used is an %% optimization for compile time and memory use during compilation. %% It is probably worthwhile because it is common to extract only a %% few elements from a huge record. select_extract_tuple(Src, Vs, Used, St0) -> Tuple = ssa_arg(Src, St0), F = fun (#k_var{name=V}, {Elem,S0}) -> case member(V, Used) of true -> Args = [Tuple,#b_literal{val=Elem}], {Dst,S} = new_ssa_var(V, S0), Get = #b_set{op=get_tuple_element,dst=Dst,args=Args}, {[Get],{Elem+1,S}}; false -> {[],{Elem+1,S0}} end end, {Es,{_,St}} = flatmapfoldl(F, {0,St0}, Vs), {Es,St}. select_map(Scs, V, Tf, Vf, St0) -> MapSrc = ssa_arg(V, St0), {Is,St1} = match_fmf(fun(#k_val_clause{val=#k_map{op=exact,es=Es}, body=B}, Fail, St1) -> select_map_val(V, Es, B, Fail, St1) end, Vf, St0, Scs), {TestIs,St} = make_cond_branch({bif,is_map}, [MapSrc], Tf, St1), {TestIs++Is,St}. select_map_val(V, Es, B, Fail, St0) -> {Eis,St1} = select_extract_map(Es, V, Fail, St0), {Bis,St2} = match_cg(B, Fail, St1), {Eis++Bis,St2}. select_extract_map([P|Ps], Src, Fail, St0) -> MapSrc = ssa_arg(Src, St0), #k_map_pair{key=Key0,val=#k_var{name=Dst0}} = P, Key = ssa_arg(Key0, St0), {Dst,St1} = new_ssa_var(Dst0, St0), Set = #b_set{op=get_map_element,dst=Dst,args=[MapSrc,Key]}, {TestIs,St2} = make_succeeded(Dst, {guard, Fail}, St1), {Is,St} = select_extract_map(Ps, Src, Fail, St2), {[Set|TestIs]++Is,St}; select_extract_map([], _, _, St) -> {[],St}. select_extract_cons(Src0, [#k_var{name=Hd},#k_var{name=Tl}], St0) -> Src = ssa_arg(Src0, St0), {HdDst,St1} = new_ssa_var(Hd, St0), {TlDst,St2} = new_ssa_var(Tl, St1), GetHd = #b_set{op=get_hd,dst=HdDst,args=[Src]}, GetTl = #b_set{op=get_tl,dst=TlDst,args=[Src]}, {[GetHd,GetTl],St2}. guard_clause_cg(#k_guard_clause{guard=G,body=B}, Fail, St0) -> {Gis,St1} = guard_cg(G, Fail, St0), {Bis,St} = match_cg(B, Fail, St1), {Gis ++ Bis,St}. %% guard_cg(Guard, Fail, State) -> {[Ainstr],State}. %% A guard is a boolean expression of tests. Tests return true or %% false. A fault in a test causes the test to return false. Tests %% never return the boolean, instead we generate jump code to go to %% the correct exit point. Primops and tests all go to the next %% instruction on success or jump to a failure label. guard_cg(#k_protected{arg=Ts,ret=Rs,inner=Inner}, Fail, St) -> protected_cg(Ts, Rs, Inner, Fail, St); guard_cg(#k_test{op=Test0,args=As}, Fail, St0) -> #k_remote{mod=#k_atom{val=erlang},name=#k_atom{val=Test}} = Test0, test_cg(Test, false, As, Fail, St0); guard_cg(#k_seq{arg=Arg,body=Body}, Fail, St0) -> {ArgIs,St1} = guard_cg(Arg, Fail, St0), {BodyIs,St} = guard_cg(Body, Fail, St1), {ArgIs++BodyIs,St}; guard_cg(G, _Fail, St) -> cg(G, St). test_cg('=/=', Inverted, As, Fail, St) -> test_cg('=:=', not Inverted, As, Fail, St); test_cg('/=', Inverted, As, Fail, St) -> test_cg('==', not Inverted, As, Fail, St); test_cg(Test, Inverted, As0, Fail, St0) -> As = ssa_args(As0, St0), case {Test,ssa_args(As0, St0)} of {is_record,[Tuple,#b_literal{val=Atom}=Tag,#b_literal{val=Int}=Arity]} when is_atom(Atom), is_integer(Int) -> false = Inverted, %Assertion. test_is_record_cg(Fail, Tuple, Tag, Arity, St0); {_,As} -> {Bool,St1} = new_ssa_var('@ssa_bool', St0), {Succ,St} = new_label(St1), Bif = #b_set{op={bif,Test},dst=Bool,args=As}, Br = case Inverted of false -> #b_br{bool=Bool,succ=Succ,fail=Fail}; true -> #b_br{bool=Bool,succ=Fail,fail=Succ} end, {[Bif,Br,{label,Succ}],St} end. test_is_record_cg(Fail, Tuple, TagVal, ArityVal, St0) -> {Arity,St1} = new_ssa_var('@ssa_arity', St0), {Tag,St2} = new_ssa_var('@ssa_tag', St1), {Is0,St3} = make_cond_branch({bif,is_tuple}, [Tuple], Fail, St2), GetArity = #b_set{op={bif,tuple_size},dst=Arity,args=[Tuple]}, {Is1,St4} = make_cond_branch({bif,'=:='}, [Arity,ArityVal], Fail, St3), GetTag = #b_set{op=get_tuple_element,dst=Tag, args=[Tuple,#b_literal{val=0}]}, {Is2,St} = make_cond_branch({bif,'=:='}, [Tag,TagVal], Fail, St4), Is = Is0 ++ [GetArity] ++ Is1 ++ [GetTag] ++ Is2, {Is,St}. %% protected_cg([Kexpr], [Ret], Fail, St) -> {[Ainstr],St}. %% Do a protected. Protecteds without return values are just done %% for effect, the return value is not checked, success passes on to %% the next instruction and failure jumps to Fail. If there are %% return values then these must be set to 'false' on failure, %% control always passes to the next instruction. protected_cg(Ts, [], _, Fail, St0) -> %% Protect these calls, revert when done. {Tis,St1} = guard_cg(Ts, Fail, St0#cg{bfail=Fail}), {Tis,St1#cg{bfail=St0#cg.bfail}}; protected_cg(Ts, Rs, Inner0, _Fail, St0) -> {Pfail,St1} = new_label(St0), {Br,St2} = new_label(St1), Prot = duplicate(length(Rs), #b_literal{val=false}), {Tis,St3} = guard_cg(Ts, Pfail, St2#cg{break=Pfail,bfail=Pfail}), Inner = ssa_args(Inner0, St3), {BreakVars,St} = new_ssa_vars(Rs, St3), Is = Tis ++ [#cg_break{args=Inner,phi=Br}, {label,Pfail},#cg_break{args=Prot,phi=Br}, {label,Br},#cg_phi{vars=BreakVars}], {Is,St#cg{break=St0#cg.break,bfail=St0#cg.bfail}}. %% match_fmf(Fun, LastFail, State, [Clause]) -> {Is,State}. %% This is a special flatmapfoldl for match code gen where we %% generate a "failure" label for each clause. The last clause uses %% an externally generated failure label, LastFail. N.B. We do not %% know or care how the failure labels are used. match_fmf(F, LastFail, St, [H]) -> F(H, LastFail, St); match_fmf(F, LastFail, St0, [H|T]) -> {Fail,St1} = new_label(St0), {R,St2} = F(H, Fail, St1), {Rs,St3} = match_fmf(F, LastFail, St2, T), {R ++ [{label,Fail}] ++ Rs,St3}. %% fail_context(State) -> {Where,FailureLabel}. %% Where = guard | no_catch | in_catch %% Return an indication of which part of a function code is %% being generated for and the appropriate failure label to %% use. %% %% Where has the following meaning: %% %% guard - Inside a guard. %% no_catch - In a function body, not in the scope of %% a try/catch or catch. %% in_catch - In the scope of a try/catch or catch. fail_context(#cg{catch_label=Catch,bfail=Fail,ultimate_failure=Ult}) -> if Fail =/= Ult -> {guard,Fail}; Catch =:= none -> {no_catch,Fail}; is_integer(Catch) -> {in_catch,Catch} end. %% call_cg(Func, [Arg], [Ret], Le, State) -> %% {[Ainstr],State}. %% enter_cg(Func, [Arg], Le, St) -> {[Ainstr],St}. %% Generate code for call and enter. call_cg(Func, As, [], Le, St) -> call_cg(Func, As, [#k_var{name='@ssa_ignored'}], Le, St); call_cg(Func0, As, [#k_var{name=R}|MoreRs]=Rs, Le, St0) -> case fail_context(St0) of {guard,Fail} -> %% Inside a guard. The only allowed function call is to %% erlang:error/1,2. We will generate a branch to the %% failure branch. #k_remote{mod=#k_atom{val=erlang}, name=#k_atom{val=error}} = Func0, %Assertion. [#k_var{name=DestVar}] = Rs, St = set_ssa_var(DestVar, #b_literal{val=unused}, St0), {[make_uncond_branch(Fail),#cg_unreachable{}],St}; FailCtx -> %% Ordinary function call in a function body. Args = ssa_args(As, St0), {Ret,St1} = new_ssa_var(R, St0), Func = call_target(Func0, Args, St0), Call = #b_set{anno=line_anno(Le),op=call,dst=Ret,args=[Func|Args]}, %% If this is a call to erlang:error(), MoreRs could be a %% nonempty list of variables that each need a value. St2 = foldl(fun(#k_var{name=Dummy}, S) -> set_ssa_var(Dummy, #b_literal{val=unused}, S) end, St1, MoreRs), {TestIs,St} = make_succeeded(Ret, FailCtx, St2), {[Call|TestIs],St} end. enter_cg(Func0, As0, Le, St0) -> Anno = line_anno(Le), Func = call_target(Func0, As0, St0), As = ssa_args(As0, St0), {Ret,St} = new_ssa_var('@ssa_ret', St0), Call = #b_set{anno=Anno,op=call,dst=Ret,args=[Func|As]}, {[Call,#b_ret{arg=Ret}],St}. call_target(Func, As, St) -> Arity = length(As), case Func of #k_remote{mod=Mod0,name=Name0} -> Mod = ssa_arg(Mod0, St), Name = ssa_arg(Name0, St), #b_remote{mod=Mod,name=Name,arity=Arity}; #k_local{name=Name} when is_atom(Name) -> #b_local{name=#b_literal{val=Name},arity=Arity}; #k_var{}=Var -> ssa_arg(Var, St) end. %% bif_cg(#k_bif{}, Le,State) -> {[Ainstr],State}. %% Generate code for a guard BIF or primop. bif_cg(#k_bif{op=#k_internal{name=Name},args=As,ret=Rs}, Le, St) -> internal_cg(Name, As, Rs, Le, St); bif_cg(#k_bif{op=#k_remote{mod=#k_atom{val=erlang},name=#k_atom{val=Name}}, args=As,ret=Rs}, Le, St) -> bif_cg(Name, As, Rs, Le, St). %% internal_cg(Bif, [Arg], [Ret], Le, State) -> %% {[Ainstr],State}. internal_cg(make_fun, [Name0,Arity0|As], Rs, _Le, St0) -> #k_atom{val=Name} = Name0, #k_int{val=Arity} = Arity0, [#k_var{name=Dst0}] = Rs, {Dst,St} = new_ssa_var(Dst0, St0), Args = ssa_args(As, St), Local = #b_local{name=#b_literal{val=Name},arity=Arity}, MakeFun = #b_set{op=make_fun,dst=Dst,args=[Local|Args]}, {[MakeFun],St}; internal_cg(bs_init_writable=I, As, [#k_var{name=Dst0}], _Le, St0) -> %% This behaves like a function call. {Dst,St} = new_ssa_var(Dst0, St0), Args = ssa_args(As, St), Set = #b_set{op=I,dst=Dst,args=Args}, {[Set],St}; internal_cg(build_stacktrace=I, As, [#k_var{name=Dst0}], _Le, St0) -> {Dst,St} = new_ssa_var(Dst0, St0), Args = ssa_args(As, St), Set = #b_set{op=I,dst=Dst,args=Args}, {[Set],St}; internal_cg(raise, As, [#k_var{name=Dst0}], _Le, St0) -> Args = ssa_args(As, St0), {Dst,St} = new_ssa_var(Dst0, St0), Resume = #b_set{op=resume,dst=Dst,args=Args}, case St of #cg{catch_label=none} -> {[Resume],St}; #cg{catch_label=Catch} when is_integer(Catch) -> Is = [Resume,make_uncond_branch(Catch),#cg_unreachable{}], {Is,St} end; internal_cg(raw_raise=I, As, [#k_var{name=Dst0}], _Le, St0) -> %% This behaves like a function call. {Dst,St} = new_ssa_var(Dst0, St0), Args = ssa_args(As, St), Set = #b_set{op=I,dst=Dst,args=Args}, {[Set],St}. bif_cg(Bif, As0, [#k_var{name=Dst0}], Le, St0) -> {Dst,St1} = new_ssa_var(Dst0, St0), case {Bif,ssa_args(As0, St0)} of {is_record,[Tuple,#b_literal{val=Atom}=Tag, #b_literal{val=Int}=Arity]} when is_atom(Atom), is_integer(Int) -> bif_is_record_cg(Dst, Tuple, Tag, Arity, St1); {_,As} -> I = #b_set{anno=line_anno(Le),op={bif,Bif},dst=Dst,args=As}, case erl_bifs:is_safe(erlang, Bif, length(As)) of false -> FailCtx = fail_context(St1), {Is,St} = make_succeeded(Dst, FailCtx, St1), {[I|Is],St}; true-> {[I],St1} end end. bif_is_record_cg(Dst, Tuple, TagVal, ArityVal, St0) -> {Arity,St1} = new_ssa_var('@ssa_arity', St0), {Tag,St2} = new_ssa_var('@ssa_tag', St1), {Phi,St3} = new_label(St2), {False,St4} = new_label(St3), {Is0,St5} = make_cond_branch({bif,is_tuple}, [Tuple], False, St4), GetArity = #b_set{op={bif,tuple_size},dst=Arity,args=[Tuple]}, {Is1,St6} = make_cond_branch({bif,'=:='}, [Arity,ArityVal], False, St5), GetTag = #b_set{op=get_tuple_element,dst=Tag, args=[Tuple,#b_literal{val=0}]}, {Is2,St} = make_cond_branch({bif,'=:='}, [Tag,TagVal], False, St6), Is3 = [#cg_break{args=[#b_literal{val=true}],phi=Phi}, {label,False}, #cg_break{args=[#b_literal{val=false}],phi=Phi}, {label,Phi}, #cg_phi{vars=[Dst]}], Is = Is0 ++ [GetArity] ++ Is1 ++ [GetTag] ++ Is2 ++ Is3, {Is,St}. %% recv_loop_cg(TimeOut, ReceiveVar, ReceiveMatch, TimeOutExprs, %% [Ret], Le, St) -> {[Ainstr],St}. recv_loop_cg(Te, Rvar, Rm, Tes, Rs, Le, St0) -> %% Get labels. {Rl,St1} = new_label(St0), {Tl,St2} = new_label(St1), {Bl,St3} = new_label(St2), St4 = St3#cg{break=Bl,recv=Rl}, {Ris,St5} = cg_recv_mesg(Rvar, Rm, Tl, Le, St4), {Wis,St6} = cg_recv_wait(Te, Tes, St5), {BreakVars,St} = new_ssa_vars(Rs, St6), {Ris ++ [{label,Tl}] ++ Wis ++ [{label,Bl},#cg_phi{vars=BreakVars}], St#cg{break=St0#cg.break,recv=St0#cg.recv}}. %% cg_recv_mesg( ) -> {[Ainstr],St}. cg_recv_mesg(#k_var{name=R}, Rm, Tl, Le, St0) -> {Dst,St1} = new_ssa_var(R, St0), {Mis,St2} = match_cg(Rm, none, St1), RecvLbl = St1#cg.recv, {TestIs,St} = make_succeeded(Dst, {guard, Tl}, St2), Is = [#b_br{anno=line_anno(Le),bool=#b_literal{val=true}, succ=RecvLbl,fail=RecvLbl}, {label,RecvLbl}, #b_set{op=peek_message,dst=Dst}|TestIs], {Is++Mis,St}. %% cg_recv_wait(Te, Tes, St) -> {[Ainstr],St}. cg_recv_wait(#k_int{val=0}, Es, St0) -> {Tis,St} = cg(Es, St0), {[#b_set{op=timeout}|Tis],St}; cg_recv_wait(Te, Es, St0) -> {Tis,St1} = cg(Es, St0), Args = [ssa_arg(Te, St1)], {WaitDst,St2} = new_ssa_var('@ssa_wait', St1), {WaitIs,St} = make_succeeded(WaitDst, {guard, St1#cg.recv}, St2), %% Infinite timeout will be optimized later. Is = [#b_set{op=wait_timeout,dst=WaitDst,args=Args}] ++ WaitIs ++ [#b_set{op=timeout}] ++ Tis, {Is,St}. %% try_cg(TryBlock, [BodyVar], TryBody, [ExcpVar], TryHandler, [Ret], St) -> %% {[Ainstr],St}. try_cg(Ta, Vs, Tb, Evs, Th, Rs, St0) -> {B,St1} = new_label(St0), %Body label {H,St2} = new_label(St1), %Handler label {E,St3} = new_label(St2), %End label {Next,St4} = new_label(St3), {TryTag,St5} = new_ssa_var('@ssa_catch_tag', St4), {SsaVs,St6} = new_ssa_vars(Vs, St5), {SsaEvs,St7} = new_ssa_vars(Evs, St6), {Ais,St8} = cg(Ta, St7#cg{break=B,catch_label=H}), St9 = St8#cg{break=E,catch_label=St7#cg.catch_label}, {Bis,St10} = cg(Tb, St9), {His,St11} = cg(Th, St10), {BreakVars,St12} = new_ssa_vars(Rs, St11), {CatchedAgg,St} = new_ssa_var('@ssa_agg', St12), ExtractVs = extract_vars(SsaEvs, CatchedAgg, 0), KillTryTag = #b_set{op=kill_try_tag,args=[TryTag]}, Args = [#b_literal{val='try'},TryTag], Handler = [{label,H}, #b_set{op=landingpad,dst=CatchedAgg,args=Args}] ++ ExtractVs ++ [KillTryTag], {[#b_set{op=new_try_tag,dst=TryTag,args=[#b_literal{val='try'}]}, #b_br{bool=TryTag,succ=Next,fail=H}, {label,Next}] ++ Ais ++ [{label,B},#cg_phi{vars=SsaVs},KillTryTag] ++ Bis ++ Handler ++ His ++ [{label,E},#cg_phi{vars=BreakVars}], St#cg{break=St0#cg.break}}. try_enter_cg(Ta, Vs, Tb, Evs, Th, St0) -> {B,St1} = new_label(St0), %Body label {H,St2} = new_label(St1), %Handler label {Next,St3} = new_label(St2), {TryTag,St4} = new_ssa_var('@ssa_catch_tag', St3), {SsaVs,St5} = new_ssa_vars(Vs, St4), {SsaEvs,St6} = new_ssa_vars(Evs, St5), {Ais,St7} = cg(Ta, St6#cg{break=B,catch_label=H}), St8 = St7#cg{catch_label=St6#cg.catch_label}, {Bis,St9} = cg(Tb, St8), {His,St10} = cg(Th, St9), {CatchedAgg,St} = new_ssa_var('@ssa_agg', St10), ExtractVs = extract_vars(SsaEvs, CatchedAgg, 0), KillTryTag = #b_set{op=kill_try_tag,args=[TryTag]}, Args = [#b_literal{val='try'},TryTag], Handler = [{label,H}, #b_set{op=landingpad,dst=CatchedAgg,args=Args}] ++ ExtractVs ++ [KillTryTag], {[#b_set{op=new_try_tag,dst=TryTag,args=[#b_literal{val='try'}]}, #b_br{bool=TryTag,succ=Next,fail=H}, {label,Next}] ++ Ais ++ [{label,B},#cg_phi{vars=SsaVs},KillTryTag] ++ Bis ++ Handler ++ His, St#cg{break=St0#cg.break}}. extract_vars([V|Vs], Agg, N) -> I = #b_set{op=extract,dst=V,args=[Agg,#b_literal{val=N}]}, [I|extract_vars(Vs, Agg, N+1)]; extract_vars([], _, _) -> []. %% do_catch_cg(CatchBlock, Ret, St) -> {[Ainstr],St}. do_catch_cg(Block, #k_var{name=R}, St0) -> {B,St1} = new_label(St0), {Next,St2} = new_label(St1), {H,St3} = new_label(St2), {CatchReg,St4} = new_ssa_var('@ssa_catch_tag', St3), {Dst,St5} = new_ssa_var(R, St4), {Succ,St6} = new_label(St5), {Cis,St7} = cg(Block, St6#cg{break=Succ,catch_label=H}), {CatchedVal,St8} = new_ssa_var('@catched_val', St7), {SuccVal,St9} = new_ssa_var('@success_val', St8), {CatchedAgg,St10} = new_ssa_var('@ssa_agg', St9), {CatchEndVal,St} = new_ssa_var('@catch_end_val', St10), Args = [#b_literal{val='catch'},CatchReg], {[#b_set{op=new_try_tag,dst=CatchReg,args=[#b_literal{val='catch'}]}, #b_br{bool=CatchReg,succ=Next,fail=H}, {label,Next}] ++ Cis ++ [{label,H}, #b_set{op=landingpad,dst=CatchedAgg,args=Args}, #b_set{op=extract,dst=CatchedVal, args=[CatchedAgg,#b_literal{val=0}]}, #cg_break{args=[CatchedVal],phi=B}, {label,Succ}, #cg_phi{vars=[SuccVal]}, #cg_break{args=[SuccVal],phi=B}, {label,B},#cg_phi{vars=[CatchEndVal]}, #b_set{op=catch_end,dst=Dst,args=[CatchReg,CatchEndVal]}], St#cg{break=St1#cg.break,catch_label=St1#cg.catch_label}}. %% put_cg([Var], Constr, Le, Vdb, Bef, St) -> {[Ainstr],St}. %% Generate code for constructing terms. put_cg([#k_var{name=R}], #k_cons{hd=Hd,tl=Tl}, _Le, St0) -> Args = ssa_args([Hd,Tl], St0), {Dst,St} = new_ssa_var(R, St0), PutList = #b_set{op=put_list,dst=Dst,args=Args}, {[PutList],St}; put_cg([#k_var{name=R}], #k_tuple{es=Es}, _Le, St0) -> {Ret,St} = new_ssa_var(R, St0), Args = ssa_args(Es, St), PutTuple = #b_set{op=put_tuple,dst=Ret,args=Args}, {[PutTuple],St}; put_cg([#k_var{name=R}], #k_binary{segs=Segs}, Le, St0) -> FailCtx = fail_context(St0), {Dst,St1} = new_ssa_var(R, St0), cg_binary(Dst, Segs, FailCtx, Le, St1); put_cg([#k_var{name=R}], #k_map{op=Op,var=Map, es=[#k_map_pair{key=#k_var{}=K,val=V}]}, Le, St0) -> %% Map: single variable key. SrcMap = ssa_arg(Map, St0), LineAnno = line_anno(Le), List = [ssa_arg(K, St0),ssa_arg(V, St0)], {Dst,St1} = new_ssa_var(R, St0), {Is,St} = put_cg_map(LineAnno, Op, SrcMap, Dst, List, St1), {Is,St}; put_cg([#k_var{name=R}], #k_map{op=Op,var=Map,es=Es}, Le, St0) -> %% Map: one or more literal keys. [] = [Var || #k_map_pair{key=#k_var{}=Var} <- Es], %Assertion SrcMap = ssa_arg(Map, St0), LineAnno = line_anno(Le), List = flatmap(fun(#k_map_pair{key=K,val=V}) -> [ssa_arg(K, St0),ssa_arg(V, St0)] end, Es), {Dst,St1} = new_ssa_var(R, St0), {Is,St} = put_cg_map(LineAnno, Op, SrcMap, Dst, List, St1), {Is,St}; put_cg([#k_var{name=R}], Con0, _Le, St0) -> %% Create an alias for a variable or literal. Con = ssa_arg(Con0, St0), St = set_ssa_var(R, Con, St0), {[],St}. put_cg_map(LineAnno, Op, SrcMap, Dst, List, St0) -> Args = [#b_literal{val=Op},SrcMap|List], PutMap = #b_set{anno=LineAnno,op=put_map,dst=Dst,args=Args}, if Op =:= assoc -> {[PutMap],St0}; true -> FailCtx = fail_context(St0), {Is,St} = make_succeeded(Dst, FailCtx, St0), {[PutMap|Is],St} end. %%% %%% Code generation for constructing binaries. %%% cg_binary(Dst, Segs0, FailCtx, Le, St0) -> {PutCode0,SzCalc0,St1} = cg_bin_put(Segs0, FailCtx, St0), LineAnno = line_anno(Le), Anno = Le#k.a, case PutCode0 of [#b_set{op=bs_put,dst=Bool,args=[_,_,Src,#b_literal{val=all}|_]}, #b_br{bool=Bool}, {label,_}|_] -> #k_bin_seg{unit=Unit0,next=Segs} = Segs0, Unit = #b_literal{val=Unit0}, {PutCode,SzCalc1,St2} = cg_bin_put(Segs, FailCtx, St1), {_,SzVar,SzCode0,St3} = cg_size_calc(1, SzCalc1, FailCtx, St2), SzCode = cg_bin_anno(SzCode0, LineAnno), Args = case member(single_use, Anno) of true -> [#b_literal{val=private_append},Src,SzVar,Unit]; false -> [#b_literal{val=append},Src,SzVar,Unit] end, BsInit = #b_set{anno=LineAnno,op=bs_init,dst=Dst,args=Args}, {TestIs,St} = make_succeeded(Dst, FailCtx, St3), {SzCode ++ [BsInit] ++ TestIs ++ PutCode,St}; [#b_set{op=bs_put}|_] -> {Unit,SzVar,SzCode0,St2} = cg_size_calc(8, SzCalc0, FailCtx, St1), SzCode = cg_bin_anno(SzCode0, LineAnno), Args = [#b_literal{val=new},SzVar,Unit], BsInit = #b_set{anno=LineAnno,op=bs_init,dst=Dst,args=Args}, {TestIs,St} = make_succeeded(Dst, FailCtx, St2), {SzCode ++ [BsInit] ++ TestIs ++ PutCode0,St} end. cg_bin_anno([Set|Sets], Anno) -> [Set#b_set{anno=Anno}|Sets]; cg_bin_anno([], _) -> []. %% cg_size_calc(PreferredUnit, SzCalc, FailCtx, St0) -> %% {ActualUnit,SizeVariable,SizeCode,St}. %% Generate size calculation code. cg_size_calc(Unit, error, _FailCtx, St) -> {#b_literal{val=Unit},#b_literal{val=badarg},[],St}; cg_size_calc(8, [{1,_}|_]=SzCalc, FailCtx, St) -> cg_size_calc(1, SzCalc, FailCtx, St); cg_size_calc(8, SzCalc, FailCtx, St0) -> {Var,Pre,St} = cg_size_calc_1(SzCalc, FailCtx, St0), {#b_literal{val=8},Var,Pre,St}; cg_size_calc(1, SzCalc0, FailCtx, St0) -> SzCalc = map(fun({8,#b_literal{val=Size}}) -> {1,#b_literal{val=8*Size}}; ({8,{{bif,byte_size},Src}}) -> {1,{{bif,bit_size},Src}}; ({8,{_,_}=UtfCalc}) -> {1,{'*',#b_literal{val=8},UtfCalc}}; ({_,_}=Pair) -> Pair end, SzCalc0), {Var,Pre,St} = cg_size_calc_1(SzCalc, FailCtx, St0), {#b_literal{val=1},Var,Pre,St}. cg_size_calc_1(SzCalc, FailCtx, St0) -> cg_size_calc_2(SzCalc, #b_literal{val=0}, FailCtx, St0). cg_size_calc_2([{_,{'*',Unit,{_,_}=Bif}}|T], Sum0, FailCtx, St0) -> {Sum1,Pre0,St1} = cg_size_calc_2(T, Sum0, FailCtx, St0), {BifDst,Pre1,St2} = cg_size_bif(Bif, FailCtx, St1), {Sum,Pre2,St} = cg_size_add(Sum1, BifDst, Unit, FailCtx, St2), {Sum,Pre0++Pre1++Pre2,St}; cg_size_calc_2([{_,#b_literal{}=Sz}|T], Sum0, FailCtx, St0) -> {Sum1,Pre0,St1} = cg_size_calc_2(T, Sum0, FailCtx, St0), {Sum,Pre,St} = cg_size_add(Sum1, Sz, #b_literal{val=1}, FailCtx, St1), {Sum,Pre0++Pre,St}; cg_size_calc_2([{_,#b_var{}=Sz}|T], Sum0, FailCtx, St0) -> {Sum1,Pre0,St1} = cg_size_calc_2(T, Sum0, FailCtx, St0), {Sum,Pre,St} = cg_size_add(Sum1, Sz, #b_literal{val=1}, FailCtx, St1), {Sum,Pre0++Pre,St}; cg_size_calc_2([{_,{_,_}=Bif}|T], Sum0, FailCtx, St0) -> {Sum1,Pre0,St1} = cg_size_calc_2(T, Sum0, FailCtx, St0), {BifDst,Pre1,St2} = cg_size_bif(Bif, FailCtx, St1), {Sum,Pre2,St} = cg_size_add(Sum1, BifDst, #b_literal{val=1}, FailCtx, St2), {Sum,Pre0++Pre1++Pre2,St}; cg_size_calc_2([], Sum, _FailCtx, St) -> {Sum,[],St}. cg_size_bif(#b_var{}=Var, _FailCtx, St) -> {Var,[],St}; cg_size_bif({Name,Src}, FailCtx, St0) -> {Dst,St1} = new_ssa_var('@ssa_bif', St0), Bif = #b_set{op=Name,dst=Dst,args=[Src]}, {TestIs,St} = make_succeeded(Dst, FailCtx, St1), {Dst,[Bif|TestIs],St}. cg_size_add(#b_literal{val=0}, Val, #b_literal{val=1}, _FailCtx, St) -> {Val,[],St}; cg_size_add(A, B, Unit, FailCtx, St0) -> {Dst,St1} = new_ssa_var('@ssa_sum', St0), {TestIs,St} = make_succeeded(Dst, FailCtx, St1), BsAdd = #b_set{op=bs_add,dst=Dst,args=[A,B,Unit]}, {Dst,[BsAdd|TestIs],St}. cg_bin_put(Seg, FailCtx, St) -> cg_bin_put_1(Seg, FailCtx, [], [], St). cg_bin_put_1(#k_bin_seg{size=Size0,unit=U,type=T,flags=Fs,seg=Src0,next=Next}, FailCtx, Acc, SzCalcAcc, St0) -> [Src,Size] = ssa_args([Src0,Size0], St0), NeedSize = bs_need_size(T), TypeArg = #b_literal{val=T}, Flags = #b_literal{val=Fs}, Unit = #b_literal{val=U}, Args = case NeedSize of true -> [TypeArg,Flags,Src,Size,Unit]; false -> [TypeArg,Flags,Src] end, %% bs_put has its own 'succeeded' logic, and should always jump directly to %% the fail label regardless of whether it's in a catch or not. {_, FailLbl} = FailCtx, {Is,St} = make_cond_branch(bs_put, Args, FailLbl, St0), SzCalc = bin_size_calc(T, Src, Size, U), cg_bin_put_1(Next, FailCtx, reverse(Is, Acc), [SzCalc|SzCalcAcc], St); cg_bin_put_1(#k_bin_end{}, _, Acc, SzCalcAcc, St) -> SzCalc = fold_size_calc(SzCalcAcc, 0, []), {reverse(Acc),SzCalc,St}. bs_need_size(utf8) -> false; bs_need_size(utf16) -> false; bs_need_size(utf32) -> false; bs_need_size(_) -> true. bin_size_calc(utf8, Src, _Size, _Unit) -> {8,{bs_utf8_size,Src}}; bin_size_calc(utf16, Src, _Size, _Unit) -> {8,{bs_utf16_size,Src}}; bin_size_calc(utf32, _Src, _Size, _Unit) -> {8,#b_literal{val=4}}; bin_size_calc(binary, Src, #b_literal{val=all}, Unit) -> case Unit rem 8 of 0 -> {8,{{bif,byte_size},Src}}; _ -> {1,{{bif,bit_size},Src}} end; bin_size_calc(_Type, _Src, Size, Unit) -> {Unit,Size}. fold_size_calc([{Unit,#b_literal{val=Size}}|T], Bits, Acc) -> if is_integer(Size) -> fold_size_calc(T, Bits + Unit*Size, Acc); true -> error end; fold_size_calc([{U,#b_var{}}=H|T], Bits, Acc) when U =:= 1; U =:= 8 -> fold_size_calc(T, Bits, [H|Acc]); fold_size_calc([{U,#b_var{}=Var}|T], Bits, Acc) -> fold_size_calc(T, Bits, [{1,{'*',#b_literal{val=U},Var}}|Acc]); fold_size_calc([{_,_}=H|T], Bits, Acc) -> fold_size_calc(T, Bits, [H|Acc]); fold_size_calc([], Bits, Acc) -> Bytes = Bits div 8, RemBits = Bits rem 8, Sizes = sort([{1,#b_literal{val=RemBits}},{8,#b_literal{val=Bytes}}|Acc]), [Pair || {_,Sz}=Pair <- Sizes, Sz =/= #b_literal{val=0}]. %%% %%% Utilities for creating the SSA types. %%% ssa_args(As, St) -> [ssa_arg(A, St) || A <- As]. ssa_arg(#k_var{name=V}, #cg{vars=Vars}) -> maps:get(V, Vars); ssa_arg(#k_literal{val=V}, _) -> #b_literal{val=V}; ssa_arg(#k_atom{val=V}, _) -> #b_literal{val=V}; ssa_arg(#k_float{val=V}, _) -> #b_literal{val=V}; ssa_arg(#k_int{val=V}, _) -> #b_literal{val=V}; ssa_arg(#k_nil{}, _) -> #b_literal{val=[]}. new_ssa_vars(Vs, St) -> mapfoldl(fun(#k_var{name=V}, S) -> new_ssa_var(V, S) end, St, Vs). new_ssa_var(VarBase, #cg{lcount=Uniq,vars=Vars}=St0) when is_atom(VarBase); is_integer(VarBase) -> case Vars of #{VarBase:=_} -> Var = #b_var{name={VarBase,Uniq}}, St = St0#cg{lcount=Uniq+1,vars=Vars#{VarBase=>Var}}, {Var,St}; #{} -> Var = #b_var{name=VarBase}, St = St0#cg{vars=Vars#{VarBase=>Var}}, {Var,St} end. set_ssa_var(VarBase, Val, #cg{vars=Vars}=St) when is_atom(VarBase); is_integer(VarBase) -> St#cg{vars=Vars#{VarBase=>Val}}. %% new_label(St) -> {L,St}. new_label(#cg{lcount=Next}=St) -> {Next,St#cg{lcount=Next+1}}. %% line_anno(Le) -> #{} | #{location:={File,Line}}. %% Create a location annotation, containing information about the %% current filename and line number. The annotation should be %% included in any operation that could cause an exception. line_anno(#k{a=Anno}) -> line_anno_1(Anno). line_anno_1([Line,{file,Name}]) when is_integer(Line) -> line_anno_2(Name, Line); line_anno_1([_|_]=A) -> {Name,Line} = find_loc(A, no_file, 0), line_anno_2(Name, Line); line_anno_1([]) -> #{}. line_anno_2(no_file, _) -> #{}; line_anno_2(_, 0) -> %% Missing line number or line number 0. #{}; line_anno_2(Name, Line) -> #{location=>{Name,Line}}. find_loc([Line|T], File, _) when is_integer(Line) -> find_loc(T, File, Line); find_loc([{file,File}|T], _, Line) -> find_loc(T, File, Line); find_loc([_|T], File, Line) -> find_loc(T, File, Line); find_loc([], File, Line) -> {File,Line}. flatmapfoldl(F, Accu0, [Hd|Tail]) -> {R,Accu1} = F(Hd, Accu0), {Rs,Accu2} = flatmapfoldl(F, Accu1, Tail), {R++Rs,Accu2}; flatmapfoldl(_, Accu, []) -> {[],Accu}. %%% %%% Finalize the code. %%% finalize(Asm0, St0) -> Asm1 = fix_phis(Asm0), {Asm,St} = fix_sets(Asm1, [], St0), {build_map(Asm),St}. fix_phis(Is) -> fix_phis_1(Is, none, #{}). fix_phis_1([{label,L},#cg_phi{vars=[]}=Phi|Is0], _Lbl, Map0) -> case maps:is_key(L, Map0) of false -> %% No #cg_break{} references this label. Nothing else can %% reference it, so it can be safely be removed. {Is,Map} = drop_upto_label(Is0, Map0), fix_phis_1(Is, none, Map); true -> %% There is a break referencing this label; probably caused %% by a try/catch whose return value is ignored. [{label,L}|fix_phis_1([Phi|Is0], L, Map0)] end; fix_phis_1([{label,L}=I|Is], _Lbl, Map) -> [I|fix_phis_1(Is, L, Map)]; fix_phis_1([#cg_unreachable{}|Is0], _Lbl, Map0) -> {Is,Map} = drop_upto_label(Is0, Map0), fix_phis_1(Is, none, Map); fix_phis_1([#cg_break{args=Args,phi=Target}|Is], Lbl, Map) when is_integer(Lbl) -> Pairs1 = case Map of #{Target:=Pairs0} -> Pairs0; #{} -> [] end, Pairs = [[{Arg,Lbl} || Arg <- Args]|Pairs1], I = make_uncond_branch(Target), [I|fix_phis_1(Is, none, Map#{Target=>Pairs})]; fix_phis_1([#cg_phi{vars=Vars}|Is0], Lbl, Map0) -> Pairs = maps:get(Lbl, Map0), Map1 = maps:remove(Lbl, Map0), case gen_phis(Vars, Pairs) of [#b_set{op=phi,args=[]}] -> {Is,Map} = drop_upto_label(Is0, Map1), Ret = #b_ret{arg=#b_literal{val=unreachable}}, [Ret|fix_phis_1(Is, none, Map)]; Phis -> Phis ++ fix_phis_1(Is0, Lbl, Map1) end; fix_phis_1([I|Is], Lbl, Map) -> [I|fix_phis_1(Is, Lbl, Map)]; fix_phis_1([], _, Map) -> [] = maps:to_list(Map), %Assertion. []. gen_phis([V|Vs], Preds0) -> {Pairs,Preds} = collect_preds(Preds0, [], []), [#b_set{op=phi,dst=V,args=Pairs}|gen_phis(Vs, Preds)]; gen_phis([], _) -> []. collect_preds([[First|Rest]|T], ColAcc, RestAcc) -> collect_preds(T, [First|ColAcc], [Rest|RestAcc]); collect_preds([], ColAcc, RestAcc) -> {keysort(2, ColAcc),RestAcc}. fix_sets([#b_set{dst=none}=Set|Is], Acc, St0) -> {Dst,St} = new_ssa_var('@ssa_ignored', St0), I = Set#b_set{dst=Dst}, fix_sets(Is, [I|Acc], St); fix_sets([I|Is], Acc, St) -> fix_sets(Is, [I|Acc], St); fix_sets([], Acc, St) -> {reverse(Acc),St}. build_map(Is) -> Blocks = build_graph_1(Is, [], []), maps:from_list(Blocks). build_graph_1([{label,L}|Is], Lbls, []) -> build_graph_1(Is, [L|Lbls], []); build_graph_1([{label,L}|Is], Lbls, [_|_]=BlockAcc) -> make_blocks(Lbls, BlockAcc) ++ build_graph_1(Is, [L], []); build_graph_1([I|Is], Lbls, BlockAcc) -> build_graph_1(Is, Lbls, [I|BlockAcc]); build_graph_1([], Lbls, BlockAcc) -> make_blocks(Lbls, BlockAcc). make_blocks(Lbls, [Last|Is0]) -> Is = reverse(Is0), Block = #b_blk{is=Is,last=Last}, [{L,Block} || L <- Lbls]. drop_upto_label([{label,_}|_]=Is, Map) -> {Is,Map}; drop_upto_label([#cg_break{phi=Target}|Is], Map) -> Pairs = case Map of #{Target:=Pairs0} -> Pairs0; #{} -> [] end, drop_upto_label(Is, Map#{Target=>Pairs}); drop_upto_label([_|Is], Map) -> drop_upto_label(Is, Map). k_get_anno(Thing) -> element(2, Thing).