Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
home:Ledest:erlang:23
erlang
2851-compiler-Remove-cerl_sets-usage.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File 2851-compiler-Remove-cerl_sets-usage.patch of Package erlang
From 827e8e6436bf6a34bbc2d9621c5fa0c941d3bb0e Mon Sep 17 00:00:00 2001 From: Wojtek Mach <wojtek@wojtekmach.pl> Date: Thu, 14 Jan 2021 12:29:36 +0100 Subject: [PATCH 1/2] compiler: Remove cerl_sets usage I used the following script to rewrite most call sites and I manually fixed up the remaining `cerl_sets:from_list/1` ones. #!/bin/sh cd lib/compiler for file in src/*.erl; do sed -E -i.bak 's/cerl_sets:(set)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:(add_element)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:(is_element)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:(del_element)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:(union)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:(intersection)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:(is_disjoint)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:(size)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:(filter)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:(to_list)/sets:\1/' $file sed -E -i.bak 's/cerl_sets:new\(\)/sets:new\(\[\{version, 2\}\]\)/' $file sed -E -i.bak 's/cerl_sets:from_list\(([A-Z][A-Za-z0-9_]*)\)/sets:from_list\(\1, \[\{version, 2\}\]\)/' $file rm -f $file.bak done --- lib/compiler/src/beam_asm.erl | 4 +- lib/compiler/src/beam_clean.erl | 8 +-- lib/compiler/src/beam_digraph.erl | 12 ++-- lib/compiler/src/beam_jump.erl | 14 ++-- lib/compiler/src/beam_ssa.erl | 38 +++++------ lib/compiler/src/beam_ssa_bool.erl | 36 +++++------ lib/compiler/src/beam_ssa_dead.erl | 36 +++++------ lib/compiler/src/beam_ssa_funs.erl | 6 +- lib/compiler/src/beam_ssa_opt.erl | 78 +++++++++++------------ lib/compiler/src/beam_ssa_pre_codegen.erl | 46 ++++++------- lib/compiler/src/beam_ssa_throw.erl | 8 +-- lib/compiler/src/beam_ssa_type.erl | 8 +-- lib/compiler/src/beam_trim.erl | 10 +-- lib/compiler/src/beam_validator.erl | 34 +++++----- lib/compiler/src/sys_core_alias.erl | 10 +-- lib/compiler/src/sys_core_fold.erl | 26 ++++---- lib/compiler/src/v3_core.erl | 6 +- lib/compiler/src/v3_kernel.erl | 24 +++---- 18 files changed, 202 insertions(+), 202 deletions(-) diff --git a/lib/compiler/src/beam_asm.erl b/lib/compiler/src/beam_asm.erl index b1cac9d171..d9de7031a0 100644 --- a/lib/compiler/src/beam_asm.erl +++ b/lib/compiler/src/beam_asm.erl @@ -67,7 +67,7 @@ assemble({Mod,Exp0,Attr0,Asm0,NumLabels}, ExtraChunks, CompileInfo, CompilerOpts Dict2 = shared_fun_wrappers(CompilerOpts, Dict1), NumFuncs = length(Asm0), {Asm,Attr} = on_load(Asm0, Attr0), - Exp = cerl_sets:from_list(Exp0), + Exp = sets:from_list(Exp0, [{version, 2}]), {Code,Dict} = assemble_1(Asm, Exp, Dict2, []), build_file(Code, Attr, Dict, NumLabels, NumFuncs, ExtraChunks, CompileInfo, CompilerOpts). @@ -112,7 +112,7 @@ insert_on_load_instruction(Is0, Entry) -> Bef ++ [El,on_load|Is]. assemble_1([{function,Name,Arity,Entry,Asm}|T], Exp, Dict0, Acc) -> - Dict1 = case cerl_sets:is_element({Name,Arity}, Exp) of + Dict1 = case sets:is_element({Name,Arity}, Exp) of true -> beam_dict:export(Name, Arity, Entry, Dict0); false -> diff --git a/lib/compiler/src/beam_clean.erl b/lib/compiler/src/beam_clean.erl index 67ac0a6201..643cc1c386 100644 --- a/lib/compiler/src/beam_clean.erl +++ b/lib/compiler/src/beam_clean.erl @@ -31,7 +31,7 @@ module({Mod,Exp,Attr,Fs0,_}, Opts) -> Order = [Lbl || {function,_,_,Lbl,_} <- Fs0], All = maps:from_list([{Lbl,Func} || {function,_,_,Lbl,_}=Func <- Fs0]), WorkList = rootset(Fs0, Exp, Attr), - Used = find_all_used(WorkList, All, cerl_sets:from_list(WorkList)), + Used = find_all_used(WorkList, All, sets:from_list(WorkList, [{version, 2}])), Fs1 = remove_unused(Order, Used, All), {Fs2,Lc} = clean_labels(Fs1), Fs3 = fix_swap(Fs2, Opts), @@ -54,7 +54,7 @@ rootset(Fs, Root0, Attr) -> %% Remove the unused functions. remove_unused([F|Fs], Used, All) -> - case cerl_sets:is_element(F, Used) of + case sets:is_element(F, Used) of false -> remove_unused(Fs, Used, All); true -> [map_get(F, All)|remove_unused(Fs, Used, All)] end; @@ -79,9 +79,9 @@ update_work_list([_|Is], Sets) -> update_work_list([], Sets) -> Sets. add_to_work_list(F, {Fs,Used}=Sets) -> - case cerl_sets:is_element(F, Used) of + case sets:is_element(F, Used) of true -> Sets; - false -> {[F|Fs],cerl_sets:add_element(F, Used)} + false -> {[F|Fs],sets:add_element(F, Used)} end. diff --git a/lib/compiler/src/beam_digraph.erl b/lib/compiler/src/beam_digraph.erl index 800fcf4c22..56d86990e3 100644 --- a/lib/compiler/src/beam_digraph.erl +++ b/lib/compiler/src/beam_digraph.erl @@ -134,7 +134,7 @@ in_neighbours(#dg{in_es=InEsMap}, V) -> -spec is_path(graph(), vertex(), vertex()) -> boolean(). is_path(G, From, To) -> - Seen = cerl_sets:new(), + Seen = sets:new([{version, 2}]), try _ = is_path_1([From], To, G, Seen), false @@ -146,11 +146,11 @@ is_path(G, From, To) -> is_path_1([To|_], To, _G, _Seen) -> throw(true); is_path_1([V|Vs], To, G, Seen0) -> - case cerl_sets:is_element(V, Seen0) of + case sets:is_element(V, Seen0) of true -> is_path_1(Vs, To, G, Seen0); false -> - Seen1 = cerl_sets:add_element(V, Seen0), + Seen1 = sets:add_element(V, Seen0), Successors = out_neighbours(G, V), Seen = is_path_1(Successors, To, G, Seen1), is_path_1(Vs, To, G, Seen) @@ -180,16 +180,16 @@ vertices(#dg{vs=Vs}) -> -spec reverse_postorder(graph(), [vertex()]) -> [vertex()]. reverse_postorder(G, Vs) -> - Seen = cerl_sets:new(), + Seen = sets:new([{version, 2}]), {RPO, _} = reverse_postorder_1(Vs, G, Seen, []), RPO. reverse_postorder_1([V|Vs], G, Seen0, Acc0) -> - case cerl_sets:is_element(V, Seen0) of + case sets:is_element(V, Seen0) of true -> reverse_postorder_1(Vs, G, Seen0, Acc0); false -> - Seen1 = cerl_sets:add_element(V, Seen0), + Seen1 = sets:add_element(V, Seen0), Successors = out_neighbours(G, V), {Acc,Seen} = reverse_postorder_1(Successors, G, Seen1, Acc0), reverse_postorder_1(Vs, G, Seen, [V|Acc]) diff --git a/lib/compiler/src/beam_jump.erl b/lib/compiler/src/beam_jump.erl index 0cb9c12f12..8738ce718f 100644 --- a/lib/compiler/src/beam_jump.erl +++ b/lib/compiler/src/beam_jump.erl @@ -548,7 +548,7 @@ extract_seq_1(_, _) -> no. { entry :: beam_asm:label(), %Entry label (must not be moved). replace :: #{beam_asm:label() := beam_asm:label()}, %Labels to replace. - labels :: cerl_sets:set() %Set of referenced labels. + labels :: sets:set() %Set of referenced labels. }). opt(Is0, CLabel) -> @@ -692,7 +692,7 @@ skip_unreachable([], Acc, St) -> %% Add one or more label to the set of used labels. -label_used({f,L}, St) -> St#st{labels=cerl_sets:add_element(L,St#st.labels)}; +label_used({f,L}, St) -> St#st{labels=sets:add_element(L,St#st.labels)}; label_used([H|T], St0) -> label_used(T, label_used(H, St0)); label_used([], St) -> St; label_used(_Other, St) -> St. @@ -700,7 +700,7 @@ label_used(_Other, St) -> St. %% Test if label is used. is_label_used(L, St) -> - cerl_sets:is_element(L, St#st.labels). + sets:is_element(L, St#st.labels). %% is_unreachable_after(Instruction) -> boolean() %% Test whether the code after Instruction is unreachable. @@ -739,7 +739,7 @@ remove_unused_labels(Is) -> rem_unused(Is, Used, []). rem_unused([{label,Lbl}=I|Is0], Used, [Prev|_]=Acc) -> - case cerl_sets:is_element(Lbl, Used) of + case sets:is_element(Lbl, Used) of false -> Is = case is_unreachable_after(Prev) of true -> drop_upto_label(Is0); @@ -761,7 +761,7 @@ initial_labels([{line,_}|Is], Acc) -> initial_labels([{label,Lbl}|Is], Acc) -> initial_labels(Is, [Lbl|Acc]); initial_labels([{func_info,_,_,_},{label,Lbl}|_], Acc) -> - cerl_sets:from_list([Lbl|Acc]). + sets:from_list([Lbl|Acc], [{version, 2}]). drop_upto_label([{label,_}|_]=Is) -> Is; drop_upto_label([_|Is]) -> drop_upto_label(Is); @@ -812,13 +812,13 @@ ulbl(I, Used) -> [] -> Used; [Lbl] -> - cerl_sets:add_element(Lbl, Used); + sets:add_element(Lbl, Used); [_|_]=L -> ulbl_list(L, Used) end. ulbl_list([L|Ls], Used) -> - ulbl_list(Ls, cerl_sets:add_element(L, Used)); + ulbl_list(Ls, sets:add_element(L, Used)); ulbl_list([], Used) -> Used. -spec instr_labels(Instruction) -> Labels when diff --git a/lib/compiler/src/beam_ssa.erl b/lib/compiler/src/beam_ssa.erl index 76303b34cb..0991c584fb 100644 --- a/lib/compiler/src/beam_ssa.erl +++ b/lib/compiler/src/beam_ssa.erl @@ -356,7 +356,7 @@ def(Ls, Blocks) -> def_unused(Ls, Unused, Blocks) -> Blks = [map_get(L, Blocks) || L <- Ls], - Preds = cerl_sets:from_list(Ls), + Preds = sets:from_list(Ls, [{version, 2}]), def_unused_1(Blks, Preds, [], Unused). %% dominators(Labels, BlockMap) -> {Dominators,Numbering}. @@ -481,7 +481,7 @@ fold_blocks(Fun, Labels, Acc0, Blocks) -> Linear :: [{label(),b_blk()}]. linearize(Blocks) -> - Seen = cerl_sets:new(), + Seen = sets:new([{version, 2}]), {Linear0,_} = linearize_1([0], Blocks, Seen, []), Linear = fix_phis(Linear0, #{}), Linear. @@ -499,7 +499,7 @@ rpo(Blocks) -> Labels :: [label()]. rpo(From, Blocks) -> - Seen = cerl_sets:new(), + Seen = sets:new([{version, 2}]), {Ls,_} = rpo_1(From, Blocks, Seen, []), Ls. @@ -523,7 +523,7 @@ between(From, To, Preds, Blocks) -> %% gathering once seen since we're only interested in the blocks in between. %% Uninteresting blocks can still be added if `From` doesn't dominate `To`, %% but that has no effect on the final result. - Filter = between_make_filter([To], Preds, cerl_sets:from_list([From])), + Filter = between_make_filter([To], Preds, sets:from_list([From], [{version, 2}])), {Paths, _} = between_rpo([From], Blocks, Filter, []), Paths. @@ -534,7 +534,7 @@ between(From, To, Preds, Blocks) -> rename_vars(Rename, Labels, Blocks) when is_list(Rename) -> rename_vars(maps:from_list(Rename), Labels, Blocks); rename_vars(Rename, Labels, Blocks) when is_map(Rename)-> - Preds = cerl_sets:from_list(Labels), + Preds = sets:from_list(Labels, [{version, 2}]), F = fun(#b_set{op=phi,args=Args0}=Set) -> Args = rename_phi_vars(Args0, Preds, Rename), normalize(Set#b_set{args=Args}); @@ -580,7 +580,7 @@ trim_unreachable(Blocks) when is_map(Blocks) -> %% Could perhaps be optimized if there is any need. maps:from_list(linearize(Blocks)); trim_unreachable([_|_]=Blocks) -> - trim_unreachable_1(Blocks, cerl_sets:from_list([0])). + trim_unreachable_1(Blocks, sets:from_list([0], [{version, 2}])). -spec used(b_blk() | b_set() | terminator()) -> [var_name()]. @@ -667,7 +667,7 @@ def_unused_is([#b_set{op=phi,dst=Dst,args=Args}|Is], %% We must be careful to only include variables that will %% be used when arriving from one of the predecessor blocks %% in Preds. - Unused1 = [V || {#b_var{}=V,L} <- Args, cerl_sets:is_element(L, Preds)], + Unused1 = [V || {#b_var{}=V,L} <- Args, sets:is_element(L, Preds)], Unused = ordsets:subtract(Unused0, ordsets:from_list(Unused1)), def_unused_is(Is, Preds, Def, Unused); def_unused_is([#b_set{dst=Dst}=I|Is], Preds, Def0, Unused0) -> @@ -753,11 +753,11 @@ flatmapfold_instrs_1([], _, Blocks, Acc) -> {Blocks,Acc}. linearize_1([L|Ls], Blocks, Seen0, Acc0) -> - case cerl_sets:is_element(L, Seen0) of + case sets:is_element(L, Seen0) of true -> linearize_1(Ls, Blocks, Seen0, Acc0); false -> - Seen1 = cerl_sets:add_element(L, Seen0), + Seen1 = sets:add_element(L, Seen0), Block = map_get(L, Blocks), Successors = successors(Block), {Acc,Seen} = linearize_1(Successors, Blocks, Seen1, Acc0), @@ -795,7 +795,7 @@ is_successor(L, Pred, S) -> trim_unreachable_1([{L,Blk0}|Bs], Seen0) -> Blk = trim_phis(Blk0, Seen0), - case cerl_sets:is_element(L, Seen0) of + case sets:is_element(L, Seen0) of false -> trim_unreachable_1(Bs, Seen0); true -> @@ -803,7 +803,7 @@ trim_unreachable_1([{L,Blk0}|Bs], Seen0) -> [] -> [{L,Blk}|trim_unreachable_1(Bs, Seen0)]; [_|_]=Successors -> - Seen = cerl_sets:union(Seen0, cerl_sets:from_list(Successors)), + Seen = sets:union(Seen0, sets:from_list(Successors, [{version, 2}])), [{L,Blk}|trim_unreachable_1(Bs, Seen)] end end; @@ -815,17 +815,17 @@ trim_phis(#b_blk{is=[#b_set{op=phi}|_]=Is0}=Blk, Seen) -> trim_phis(Blk, _Seen) -> Blk. trim_phis_1([#b_set{op=phi,args=Args0}=I|Is], Seen) -> - Args = [P || {_,L}=P <- Args0, cerl_sets:is_element(L, Seen)], + Args = [P || {_,L}=P <- Args0, sets:is_element(L, Seen)], [I#b_set{args=Args}|trim_phis_1(Is, Seen)]; trim_phis_1(Is, _Seen) -> Is. between_make_filter([L | Ls], Preds, Acc0) -> - case cerl_sets:is_element(L, Acc0) of + case sets:is_element(L, Acc0) of true -> between_make_filter(Ls, Preds, Acc0); false -> Next = map_get(L, Preds), - Acc1 = cerl_sets:add_element(L, Acc0), + Acc1 = sets:add_element(L, Acc0), Acc = between_make_filter(Next, Preds, Acc1), between_make_filter(Ls, Preds, Acc) @@ -834,10 +834,10 @@ between_make_filter([], _Preds, Acc) -> Acc. between_rpo([L | Ls], Blocks, Filter0, Acc0) -> - case cerl_sets:is_element(L, Filter0) of + case sets:is_element(L, Filter0) of true -> Block = map_get(L, Blocks), - Filter1 = cerl_sets:del_element(L, Filter0), + Filter1 = sets:del_element(L, Filter0), Successors = successors(Block), {Acc, Filter} = between_rpo(Successors, Blocks, Filter1, Acc0), @@ -849,12 +849,12 @@ between_rpo([], _, Filter, Acc) -> {Acc, Filter}. rpo_1([L|Ls], Blocks, Seen0, Acc0) -> - case cerl_sets:is_element(L, Seen0) of + case sets:is_element(L, Seen0) of true -> rpo_1(Ls, Blocks, Seen0, Acc0); false -> Block = map_get(L, Blocks), - Seen1 = cerl_sets:add_element(L, Seen0), + Seen1 = sets:add_element(L, Seen0), Successors = successors(Block), {Acc,Seen} = rpo_1(Successors, Blocks, Seen1, Acc0), rpo_1(Ls, Blocks, Seen, [L|Acc]) @@ -874,7 +874,7 @@ rename_var(#b_remote{mod=Mod0,name=Name0}=Remote, Rename) -> rename_var(Old, _) -> Old. rename_phi_vars([{Var,L}|As], Preds, Ren) -> - case cerl_sets:is_element(L, Preds) of + case sets:is_element(L, Preds) of true -> [{rename_var(Var, Ren),L}|rename_phi_vars(As, Preds, Ren)]; false -> diff --git a/lib/compiler/src/beam_ssa_bool.erl b/lib/compiler/src/beam_ssa_bool.erl index b3b41e68c3..1404d8197f 100644 --- a/lib/compiler/src/beam_ssa_bool.erl +++ b/lib/compiler/src/beam_ssa_bool.erl @@ -208,7 +208,7 @@ pre_opt(Blocks, Count) -> Sub = maps:remove(uses, Sub1), %% Now do the actual optimizations. - Reached = cerl_sets:from_list([hd(Top)]), + Reached = sets:from_list([hd(Top)], [{version, 2}]), pre_opt(Top, Sub, Reached, Count, Blocks). -spec get_phi_info(Ls, Blocks, Sub0) -> Sub when @@ -288,7 +288,7 @@ get_phi_info_single_use(Var, Sub) -> -spec pre_opt(Ls, Sub, Reached, Count0, Blocks0) -> {Blocks,Count} when Ls :: [beam_ssa:label()], - Reached :: cerl_sets:set(beam_ssa:label()), + Reached :: sets:set(beam_ssa:label()), Count0 :: beam_ssa:label(), Blocks0 :: beam_ssa:block_map(), Sub :: pre_sub_map(), @@ -296,7 +296,7 @@ get_phi_info_single_use(Var, Sub) -> Blocks :: beam_ssa:block_map(). pre_opt([L|Ls], Sub0, Reached0, Count0, Blocks) -> - case cerl_sets:is_element(L, Reached0) of + case sets:is_element(L, Reached0) of false -> %% This block will never be reached. pre_opt(Ls, Sub0, Reached0, Count0, maps:remove(L, Blocks)); @@ -313,14 +313,14 @@ pre_opt([L|Ls], Sub0, Reached0, Count0, Blocks) -> Br = beam_ssa:normalize(Br0#b_br{bool=Bool}), Blk = Blk0#b_blk{is=Is++[Test],last=Br}, Successors = beam_ssa:successors(Blk), - Reached = cerl_sets:union(Reached0, - cerl_sets:from_list(Successors)), + Reached = sets:union(Reached0, + sets:from_list(Successors, [{version, 2}])), pre_opt(Ls, Sub, Reached, Count, Blocks#{L:=Blk}); Last -> Blk = Blk0#b_blk{is=Is,last=Last}, Successors = beam_ssa:successors(Blk), - Reached = cerl_sets:union(Reached0, - cerl_sets:from_list(Successors)), + Reached = sets:union(Reached0, + sets:from_list(Successors, [{version, 2}])), pre_opt(Ls, Sub, Reached, Count0, Blocks#{L:=Blk}) end end; @@ -329,7 +329,7 @@ pre_opt([], _, _, Count, Blocks) -> pre_opt_is([#b_set{op=phi,dst=Dst,args=Args0}=I0|Is], Reached, Sub0, Acc) -> Args1 = [{Val,From} || {Val,From} <- Args0, - cerl_sets:is_element(From, Reached)], + sets:is_element(From, Reached)], Args = sub_args(Args1, Sub0), case all_same(Args) of true -> @@ -751,7 +751,7 @@ split_dom_block_is([], PreAcc) -> collect_digraph_blocks(FirstL, LastL, #b_br{succ=Succ,fail=Fail}, Blocks) -> Ws = gb_sets:singleton(FirstL), - Seen = cerl_sets:from_list([Succ,Fail]), + Seen = sets:from_list([Succ,Fail], [{version, 2}]), collect_digraph_blocks(Ws, LastL, Blocks, Seen, []). collect_digraph_blocks(Ws0, LastL, Blocks, Seen0, Acc0) -> @@ -760,7 +760,7 @@ collect_digraph_blocks(Ws0, LastL, Blocks, Seen0, Acc0) -> Acc0; false -> {L,Ws1} = gb_sets:take_smallest(Ws0), - Seen = cerl_sets:add_element(L, Seen0), + Seen = sets:add_element(L, Seen0), Blk = map_get(L, Blocks), Acc = [{L,Blk}|Acc0], Ws = cdb_update_workset(L, Blk, LastL, Seen, Ws1), @@ -774,7 +774,7 @@ cdb_update_workset(_L, Blk, _LastL, Seen, Ws) -> cdb_update_workset(Successors, Seen, Ws). cdb_update_workset([L|Ls], Seen, Ws) -> - case cerl_sets:is_element(L, Seen) of + case sets:is_element(L, Seen) of true -> cdb_update_workset(Ls, Seen, Ws); false -> @@ -1509,16 +1509,16 @@ join_inits_1([], VarMap) -> %%% digraph_to_ssa(Ls, G, Blocks0) -> - Seen = cerl_sets:new(), + Seen = sets:new([{version, 2}]), {Blocks,_} = digraph_to_ssa(Ls, G, Blocks0, Seen), Blocks. digraph_to_ssa([L|Ls], G, Blocks0, Seen0) -> - Seen1 = cerl_sets:add_element(L, Seen0), + Seen1 = sets:add_element(L, Seen0), {Blk,Successors0} = digraph_to_ssa_blk(L, G, Blocks0, []), Blocks1 = Blocks0#{L=>Blk}, Successors = [S || S <- Successors0, - not cerl_sets:is_element(S, Seen1)], + not sets:is_element(S, Seen1)], {Blocks,Seen} = digraph_to_ssa(Successors, G, Blocks1, Seen1), digraph_to_ssa(Ls, G, Blocks, Seen); digraph_to_ssa([], _G, Blocks, Seen) -> @@ -1629,16 +1629,16 @@ del_out_edges(V, G) -> beam_digraph:del_edges(G, beam_digraph:out_edges(G, V)). covered(From, To, G) -> - Seen0 = cerl_sets:new(), + Seen0 = sets:new([{version, 2}]), {yes,Seen} = covered_1(From, To, G, Seen0), - cerl_sets:to_list(Seen). + sets:to_list(Seen). covered_1(To, To, _G, Seen) -> {yes,Seen}; covered_1(From, To, G, Seen0) -> Vs0 = beam_digraph:out_neighbours(G, From), - Vs = [V || V <- Vs0, not cerl_sets:is_element(V, Seen0)], - Seen = cerl_sets:union(cerl_sets:from_list(Vs), Seen0), + Vs = [V || V <- Vs0, not sets:is_element(V, Seen0)], + Seen = sets:union(sets:from_list(Vs, [{version, 2}]), Seen0), case Vs of [] -> no; diff --git a/lib/compiler/src/beam_ssa_dead.erl b/lib/compiler/src/beam_ssa_dead.erl index a62da9dac2..7af48c0860 100644 --- a/lib/compiler/src/beam_ssa_dead.erl +++ b/lib/compiler/src/beam_ssa_dead.erl @@ -30,7 +30,7 @@ -import(lists, [append/1,keymember/3,last/1,member/2, reverse/1,sort/1,takewhile/2]). --type used_vars() :: #{beam_ssa:label():=cerl_sets:set(beam_ssa:var_name())}. +-type used_vars() :: #{beam_ssa:label():=sets:set(beam_ssa:var_name())}. -type basic_type_test() :: atom() | {'is_tagged_tuple',pos_integer(),atom()}. -type type_test() :: basic_type_test() | {'not',basic_type_test()}. @@ -177,7 +177,7 @@ shortcut(L, _From, Bs, #st{rel_op=none,target=one_way}) when map_size(Bs) =:= 0 %% is `one_way`, it implies the From block has a two-way `br` terminator. #b_br{bool=#b_literal{val=true},succ=L,fail=L}; shortcut(L, From, Bs, St) -> - shortcut_1(L, From, Bs, cerl_sets:new(), St). + shortcut_1(L, From, Bs, sets:new([{version, 2}]), St). shortcut_1(L, From, Bs0, UnsetVars0, St) -> case shortcut_2(L, From, Bs0, UnsetVars0, St) of @@ -195,7 +195,7 @@ shortcut_1(L, From, Bs0, UnsetVars0, St) -> %% Try to shortcut this block, branching to a successor. shortcut_2(L, From, Bs, UnsetVars, St) -> - case cerl_sets:size(UnsetVars) of + case sets:size(UnsetVars) of SetSize when SetSize > 64 -> %% This is an heuristic to limit the search for a forced label %% before it drastically slows down the compiler. Experiments @@ -383,7 +383,7 @@ update_unset_vars(L, Is, Br, UnsetVars, #st{skippable=Skippable}) -> %% Some variables defined in this block are used by %% successors. We must update the set of unset variables. SetInThisBlock = [V || #b_set{dst=V} <- Is], - cerl_sets:union(UnsetVars, cerl_sets:from_list(SetInThisBlock)) + sets:union(UnsetVars, sets:from_list(SetInThisBlock, [{version, 2}])) end. shortcut_two_way(#b_br{succ=Succ,fail=Fail}, From, Bs0, UnsetVars0, St0) -> @@ -412,14 +412,14 @@ is_br_safe(UnsetVars, Br, #st{us=Us}=St) -> %% A two-way branch never branches to a phi node, so there %% is no need to check for phi nodes here. - not cerl_sets:is_element(V, UnsetVars) andalso - cerl_sets:is_disjoint(Used0, UnsetVars) andalso - cerl_sets:is_disjoint(Used1, UnsetVars); + not sets:is_element(V, UnsetVars) andalso + sets:is_disjoint(Used0, UnsetVars) andalso + sets:is_disjoint(Used1, UnsetVars); #b_br{succ=Same,fail=Same} -> %% An unconditional branch must not jump to %% a phi node. not is_forbidden(Same, St) andalso - cerl_sets:is_disjoint(map_get(Same, Us), UnsetVars) + sets:is_disjoint(map_get(Same, Us), UnsetVars) end. is_forbidden(L, St) -> @@ -546,7 +546,7 @@ eval_switch_1([], _Arg, _PrevOp, Fail) -> Fail. bind_var_if_used(L, Var, Val, #st{us=Us}) -> - case cerl_sets:is_element(Var, map_get(L, Us)) of + case sets:is_element(Var, map_get(L, Us)) of true -> #{Var=>Val}; false -> #{} end. @@ -1057,7 +1057,7 @@ used_vars([{L,#b_blk{is=Is}=Blk}|Bs], UsedVars0, Skip0) -> %% shortcut_opt/1. Successors = beam_ssa:successors(Blk), - Used0 = used_vars_succ(Successors, L, UsedVars0, cerl_sets:new()), + Used0 = used_vars_succ(Successors, L, UsedVars0, sets:new([{version, 2}])), Used = used_vars_blk(Blk, Used0), UsedVars = used_vars_phis(Is, L, Used, UsedVars0), @@ -1068,8 +1068,8 @@ used_vars([{L,#b_blk{is=Is}=Blk}|Bs], UsedVars0, Skip0) -> %% shortcut_opt/1. Defined0 = [Def || #b_set{dst=Def} <- Is], - Defined = cerl_sets:from_list(Defined0), - MaySkip = cerl_sets:is_disjoint(Defined, Used0), + Defined = sets:from_list(Defined0, [{version, 2}]), + MaySkip = sets:is_disjoint(Defined, Used0), case MaySkip of true -> Skip = Skip0#{L=>true}, @@ -1086,11 +1086,11 @@ used_vars_succ([S|Ss], L, LiveMap, Live0) -> #{Key:=Live} -> %% The successor has a phi node, and the value for %% this block in the phi node is a variable. - used_vars_succ(Ss, L, LiveMap, cerl_sets:union(Live, Live0)); + used_vars_succ(Ss, L, LiveMap, sets:union(Live, Live0)); #{S:=Live} -> %% No phi node in the successor, or the value for %% this block in the phi node is a literal. - used_vars_succ(Ss, L, LiveMap, cerl_sets:union(Live, Live0)); + used_vars_succ(Ss, L, LiveMap, sets:union(Live, Live0)); #{} -> %% A peek_message block which has not been processed yet. used_vars_succ(Ss, L, LiveMap, Live0) @@ -1108,7 +1108,7 @@ used_vars_phis(Is, L, Live0, UsedVars0) -> case [{P,V} || {#b_var{}=V,P} <- PhiArgs] of [_|_]=PhiVars -> PhiLive0 = rel2fam(PhiVars), - PhiLive = [{{L,P},cerl_sets:union(cerl_sets:from_list(Vs), Live0)} || + PhiLive = [{{L,P},sets:union(sets:from_list(Vs, [{version, 2}]), Live0)} || {P,Vs} <- PhiLive0], maps:merge(UsedVars, maps:from_list(PhiLive)); [] -> @@ -1118,14 +1118,14 @@ used_vars_phis(Is, L, Live0, UsedVars0) -> end. used_vars_blk(#b_blk{is=Is,last=Last}, Used0) -> - Used = cerl_sets:union(Used0, cerl_sets:from_list(beam_ssa:used(Last))), + Used = sets:union(Used0, sets:from_list(beam_ssa:used(Last), [{version, 2}])), used_vars_is(reverse(Is), Used). used_vars_is([#b_set{op=phi}|Is], Used) -> used_vars_is(Is, Used); used_vars_is([#b_set{dst=Dst}=I|Is], Used0) -> - Used1 = cerl_sets:union(Used0, cerl_sets:from_list(beam_ssa:used(I))), - Used = cerl_sets:del_element(Dst, Used1), + Used1 = sets:union(Used0, sets:from_list(beam_ssa:used(I), [{version, 2}])), + Used = sets:del_element(Dst, Used1), used_vars_is(Is, Used); used_vars_is([], Used) -> Used. diff --git a/lib/compiler/src/beam_ssa_funs.erl b/lib/compiler/src/beam_ssa_funs.erl index 394a631708..2b2feb5656 100644 --- a/lib/compiler/src/beam_ssa_funs.erl +++ b/lib/compiler/src/beam_ssa_funs.erl @@ -134,17 +134,17 @@ lfo_optimize_is([], _LFuns, _Trampolines) -> []. lfo_short_circuit(Call, Trampolines) -> - lfo_short_circuit(Call, Trampolines, cerl_sets:new()). + lfo_short_circuit(Call, Trampolines, sets:new([{version, 2}])). lfo_short_circuit(Call, Trampolines, Seen0) -> %% Beware of infinite loops! Get out if this call has been seen before. - case cerl_sets:is_element(Call, Seen0) of + case sets:is_element(Call, Seen0) of true -> Call; false -> case Trampolines of #{Call := Other} -> - Seen = cerl_sets:add_element(Call, Seen0), + Seen = sets:add_element(Call, Seen0), lfo_short_circuit(Other, Trampolines, Seen); #{} -> Call diff --git a/lib/compiler/src/beam_ssa_opt.erl b/lib/compiler/src/beam_ssa_opt.erl index 0b14e6eda3..72eb8ea3f1 100644 --- a/lib/compiler/src/beam_ssa_opt.erl +++ b/lib/compiler/src/beam_ssa_opt.erl @@ -96,7 +96,7 @@ fixpoint(_FuncIds, _Order, _Passes, StMap, FuncDb, 0) -> fixpoint(FuncIds0, Order0, Passes, StMap0, FuncDb0, N) -> {StMap, FuncDb} = phase(FuncIds0, Passes, StMap0, FuncDb0), Repeat = changed(FuncIds0, FuncDb0, FuncDb, StMap0, StMap), - case cerl_sets:size(Repeat) of + case sets:size(Repeat) of 0 -> %% No change. Fixpoint reached. {StMap, FuncDb}; @@ -106,7 +106,7 @@ fixpoint(FuncIds0, Order0, Passes, StMap0, FuncDb0, N) -> %% information. {OrderA, OrderB} = Order0, Order = {OrderB, OrderA}, - FuncIds = [Id || Id <- OrderA, cerl_sets:is_element(Id, Repeat)], + FuncIds = [Id || Id <- OrderA, sets:is_element(Id, Repeat)], fixpoint(FuncIds, Order, Passes, StMap, FuncDb, N - 1) end. @@ -133,7 +133,7 @@ changed(PrevIds, FuncDb0, FuncDb, StMap0, StMap) -> %% have been updated for functions not included in the previous run. F = fun(Id, A) -> - case cerl_sets:is_element(Id, A) of + case sets:is_element(Id, A) of true -> A; false -> @@ -162,7 +162,7 @@ changed(PrevIds, FuncDb0, FuncDb, StMap0, StMap) -> end end end, - Ids = foldl(F, cerl_sets:new(), maps:keys(FuncDb)), + Ids = foldl(F, sets:new([{version, 2}]), maps:keys(FuncDb)), %% From all functions that were optimized in the previous run, %% find the functions that had any change in the SSA code. Those @@ -175,7 +175,7 @@ changed(PrevIds, FuncDb0, FuncDb, StMap0, StMap) -> %% optimization turned off (and thus not included in FuncDb). foldl(fun(Id, A) -> - case cerl_sets:is_element(Id, A) of + case sets:is_element(Id, A) of true -> %% Already scheduled for another optimization. %% No need to compare the SSA code. @@ -184,17 +184,17 @@ changed(PrevIds, FuncDb0, FuncDb, StMap0, StMap) -> %% Compare the SSA code before and after optimization. case {map_get(Id, StMap0),map_get(Id, StMap)} of {Same,Same} -> A; - {_,_} -> cerl_sets:add_element(Id, A) + {_,_} -> sets:add_element(Id, A) end end end, Ids, PrevIds). add_changed([Id|Ids], Opts, FuncDb, S0) when is_map_key(Id, FuncDb) -> - case cerl_sets:is_element(Id, S0) of + case sets:is_element(Id, S0) of true -> add_changed(Ids, Opts, FuncDb, S0); false -> - S1 = cerl_sets:add_element(Id, S0), + S1 = sets:add_element(Id, S0), #func_info{in=In,out=Out} = map_get(Id, FuncDb), S2 = case member(callers, Opts) of true -> add_changed(In, Opts, FuncDb, S1); @@ -417,16 +417,16 @@ get_call_order_po(StMap, FuncDb) -> gco_po(FuncDb) -> All = sort(maps:keys(FuncDb)), - {RPO,_} = gco_rpo(All, FuncDb, cerl_sets:new(), []), + {RPO,_} = gco_rpo(All, FuncDb, sets:new([{version, 2}]), []), reverse(RPO). gco_rpo([Id|Ids], FuncDb, Seen0, Acc0) -> - case cerl_sets:is_element(Id, Seen0) of + case sets:is_element(Id, Seen0) of true -> gco_rpo(Ids, FuncDb, Seen0, Acc0); false -> #func_info{out=Successors} = map_get(Id, FuncDb), - Seen1 = cerl_sets:add_element(Id, Seen0), + Seen1 = sets:add_element(Id, Seen0), {Acc,Seen} = gco_rpo(Successors, FuncDb, Seen1, Acc0), gco_rpo(Ids, FuncDb, Seen, [Id|Acc]) end; @@ -1037,7 +1037,7 @@ cse_suitable(#b_set{}) -> false. -record(fs, {s=undefined :: 'undefined' | 'cleared', regs=#{} :: #{beam_ssa:b_var():=beam_ssa:b_var()}, - vars=cerl_sets:new() :: cerl_sets:set(), + vars=sets:new([{version, 2}]) :: sets:set(), fail=none :: 'none' | beam_ssa:label(), non_guards :: gb_sets:set(beam_ssa:label()), bs :: beam_ssa:block_map() @@ -1213,7 +1213,7 @@ float_make_op(#b_set{op={bif,Op},dst=Dst,args=As0,anno=Anno}=I0, {Fr,Count2} = new_reg('@fr', Count1), FrDst = #b_var{name=Fr}, I = I0#b_set{op={float,Op},dst=FrDst,args=As}, - Vs = cerl_sets:add_element(Dst, Vs0), + Vs = sets:add_element(Dst, Vs0), Rs = Rs1#{Dst=>FrDst}, Is = append(Is0) ++ [I], case S of @@ -1297,7 +1297,7 @@ ssa_opt_live({#opt_st{ssa=Linear0}=St, FuncDb}) -> live_opt([{L,Blk0}|Bs], LiveMap0, Blocks) -> Blk1 = beam_ssa_share:block(Blk0, Blocks), Successors = beam_ssa:successors(Blk1), - Live0 = live_opt_succ(Successors, L, LiveMap0, cerl_sets:new()), + Live0 = live_opt_succ(Successors, L, LiveMap0, sets:new([{version, 2}])), {Blk,Live} = live_opt_blk(Blk1, Live0), LiveMap = live_opt_phis(Blk#b_blk.is, L, Live, LiveMap0), live_opt(Bs, LiveMap, Blocks#{L:=Blk}); @@ -1308,11 +1308,11 @@ live_opt_succ([S|Ss], L, LiveMap, Live0) -> #{{S,L}:=Live} -> %% The successor has a phi node, and the value for %% this block in the phi node is a variable. - live_opt_succ(Ss, L, LiveMap, cerl_sets:union(Live0, Live)); + live_opt_succ(Ss, L, LiveMap, sets:union(Live0, Live)); #{S:=Live} -> %% No phi node in the successor, or the value for %% this block in the phi node is a literal. - live_opt_succ(Ss, L, LiveMap, cerl_sets:union(Live0, Live)); + live_opt_succ(Ss, L, LiveMap, sets:union(Live0, Live)); #{} -> %% A peek_message block which has not been processed yet. live_opt_succ(Ss, L, LiveMap, Live0) @@ -1330,7 +1330,7 @@ live_opt_phis(Is, L, Live0, LiveMap0) -> case [{P,V} || {#b_var{}=V,P} <- PhiArgs] of [_|_]=PhiVars -> PhiLive0 = rel2fam(PhiVars), - PhiLive = [{{L,P},cerl_sets:union(cerl_sets:from_list(Vs), Live0)} || + PhiLive = [{{L,P},sets:union(sets:from_list(Vs, [{version, 2}]), Live0)} || {P,Vs} <- PhiLive0], maps:merge(LiveMap, maps:from_list(PhiLive)); [] -> @@ -1340,13 +1340,13 @@ live_opt_phis(Is, L, Live0, LiveMap0) -> end. live_opt_blk(#b_blk{is=Is0,last=Last}=Blk, Live0) -> - Live1 = cerl_sets:union(Live0, cerl_sets:from_list(beam_ssa:used(Last))), + Live1 = sets:union(Live0, sets:from_list(beam_ssa:used(Last), [{version, 2}])), {Is,Live} = live_opt_is(reverse(Is0), Live1, []), {Blk#b_blk{is=Is},Live}. live_opt_is([#b_set{op=phi,dst=Dst}=I|Is], Live0, Acc) -> - Live = cerl_sets:del_element(Dst, Live0), - case cerl_sets:is_element(Dst, Live0) of + Live = sets:del_element(Dst, Live0), + case sets:is_element(Dst, Live0) of true -> live_opt_is(Is, Live, [I|Acc]); false -> @@ -1355,10 +1355,10 @@ live_opt_is([#b_set{op=phi,dst=Dst}=I|Is], Live0, Acc) -> live_opt_is([#b_set{op={succeeded,guard},dst=SuccDst,args=[Dst]}=SuccI, #b_set{op=Op,dst=Dst}=I0|Is], Live0, Acc) -> - case {cerl_sets:is_element(SuccDst, Live0), - cerl_sets:is_element(Dst, Live0)} of + case {sets:is_element(SuccDst, Live0), + sets:is_element(Dst, Live0)} of {true, true} -> - Live = cerl_sets:del_element(SuccDst, Live0), + Live = sets:del_element(SuccDst, Live0), live_opt_is([I0|Is], Live, [SuccI|Acc]); {true, false} -> %% The result of the instruction before {succeeded,guard} is @@ -1378,8 +1378,8 @@ live_opt_is([#b_set{op={succeeded,guard},dst=SuccDst,args=[Dst]}=SuccI, I = I0#b_set{op=has_map_field,dst=SuccDst}, live_opt_is([I|Is], Live0, Acc); _ -> - Live1 = cerl_sets:del_element(SuccDst, Live0), - Live = cerl_sets:add_element(Dst, Live1), + Live1 = sets:del_element(SuccDst, Live0), + Live = sets:add_element(Dst, Live1), live_opt_is([I0|Is], Live, [SuccI|Acc]) end; {false, true} -> @@ -1388,19 +1388,19 @@ live_opt_is([#b_set{op={succeeded,guard},dst=SuccDst,args=[Dst]}=SuccI, live_opt_is(Is, Live0, Acc) end; live_opt_is([#b_set{dst=Dst}=I|Is], Live0, Acc) -> - case cerl_sets:is_element(Dst, Live0) of + case sets:is_element(Dst, Live0) of true -> - LiveUsed = cerl_sets:from_list(beam_ssa:used(I)), - Live1 = cerl_sets:union(Live0, LiveUsed), - Live = cerl_sets:del_element(Dst, Live1), + LiveUsed = sets:from_list(beam_ssa:used(I), [{version, 2}]), + Live1 = sets:union(Live0, LiveUsed), + Live = sets:del_element(Dst, Live1), live_opt_is(Is, Live, [I|Acc]); false -> case beam_ssa:no_side_effect(I) of true -> live_opt_is(Is, Live0, Acc); false -> - LiveUsed = cerl_sets:from_list(beam_ssa:used(I)), - Live = cerl_sets:union(Live0, LiveUsed), + LiveUsed = sets:from_list(beam_ssa:used(I), [{version, 2}]), + Live = sets:union(Live0, LiveUsed), live_opt_is(Is, Live, [I|Acc]) end end; @@ -1434,7 +1434,7 @@ ssa_opt_try({#opt_st{ssa=Linear0}=St, FuncDb}) -> opt_try([{L,#b_blk{is=[#b_set{op=new_try_tag}], last=Last}=Blk0}|Bs0]) -> #b_br{succ=Succ,fail=Fail} = Last, - Ws = cerl_sets:from_list([Succ,Fail]), + Ws = sets:from_list([Succ,Fail], [{version, 2}]), try do_opt_try(Bs0, Ws) of Bs -> Blk = Blk0#b_blk{is=[], @@ -1450,24 +1450,24 @@ opt_try([{L,Blk}|Bs]) -> opt_try([]) -> []. do_opt_try([{L,Blk}|Bs]=Bs0, Ws0) -> - case cerl_sets:is_element(L, Ws0) of + case sets:is_element(L, Ws0) of false -> %% This block is not reachable from the block with the %% `new_try_tag` instruction. Retain it. There is no %% need to check it for safety. - case cerl_sets:size(Ws0) of + case sets:size(Ws0) of 0 -> Bs0; _ -> [{L,Blk}|do_opt_try(Bs, Ws0)] end; true -> - Ws1 = cerl_sets:del_element(L, Ws0), + Ws1 = sets:del_element(L, Ws0), #b_blk{is=Is0} = Blk, case is_safe_without_try(Is0, []) of {safe,Is} -> %% This block does not execute any instructions %% that would require a try. Analyze successors. Successors = beam_ssa:successors(Blk), - Ws = cerl_sets:union(cerl_sets:from_list(Successors), + Ws = sets:union(sets:from_list(Successors, [{version, 2}]), Ws1), [{L,Blk#b_blk{is=Is}}|do_opt_try(Bs, Ws)]; unsafe -> @@ -1483,7 +1483,7 @@ do_opt_try([{L,Blk}|Bs]=Bs0, Ws0) -> end end; do_opt_try([], Ws) -> - 0 = cerl_sets:size(Ws), %Assertion. + 0 = sets:size(Ws), %Assertion. []. is_safe_without_try([#b_set{op=kill_try_tag}|Is], Acc) -> @@ -1526,7 +1526,7 @@ is_safe_without_try([], Acc) -> ssa_opt_bsm({#opt_st{ssa=Linear}=St, FuncDb}) -> Extracted0 = bsm_extracted(Linear), - Extracted = cerl_sets:from_list(Extracted0), + Extracted = sets:from_list(Extracted0, [{version, 2}]), {St#opt_st{ssa=bsm_skip(Linear, Extracted)}, FuncDb}. bsm_skip([{L,#b_blk{is=Is0}=Blk}|Bs0], Extracted) -> @@ -1543,7 +1543,7 @@ bsm_skip_is([I0|Is], Extracted) -> when T =/= float, T =/= string, T =/= skip -> %% Note that it is never safe to skip matching %% of floats, even if the size is known to be correct. - I = case cerl_sets:is_element(Ctx, Extracted) of + I = case sets:is_element(Ctx, Extracted) of true -> I0; false -> diff --git a/lib/compiler/src/beam_ssa_pre_codegen.erl b/lib/compiler/src/beam_ssa_pre_codegen.erl index 7fa018d7e8..6cda7b19de 100644 --- a/lib/compiler/src/beam_ssa_pre_codegen.erl +++ b/lib/compiler/src/beam_ssa_pre_codegen.erl @@ -1672,7 +1672,7 @@ find_loop_exit([_,_|_]=RmBlocks, Blocks) -> %% remove_message blocks. RPO = beam_ssa:rpo(Blocks), {Dominators,_} = beam_ssa:dominators(RPO, Blocks), - RmSet = cerl_sets:from_list(RmBlocks), + RmSet = sets:from_list(RmBlocks, [{version, 2}]), RmRPO = beam_ssa:rpo(RmBlocks, Blocks), find_loop_exit_1(RmRPO, RmSet, Dominators, Blocks); find_loop_exit(_, _) -> @@ -1686,7 +1686,7 @@ find_loop_exit_1([?EXCEPTION_BLOCK|Ls], RmSet, Dominators, Blocks) -> find_loop_exit_1(Ls, RmSet, Dominators, Blocks); find_loop_exit_1([L|Ls0], RmSet, Dominators, Blocks) -> DomBy = map_get(L, Dominators), - case any(fun(E) -> cerl_sets:is_element(E, RmSet) end, DomBy) of + case any(fun(E) -> sets:is_element(E, RmSet) end, DomBy) of true -> %% This block is dominated by one of the remove_message blocks, %% which means that the block is part of only one clause. @@ -1767,7 +1767,7 @@ find_rm_act([]) -> %%% -record(dk, {d :: ordsets:ordset(var_name()), - k :: cerl_sets:set(var_name()) + k :: sets:set(var_name()) }). %% find_yregs(St0) -> St. @@ -1790,10 +1790,10 @@ find_yregs(#st{frames=[_|_]=Frames,args=Args,ssa=Blocks0}=St) -> St#st{ssa=Blocks}. find_yregs_1([{F,Defs}|Fs], Blocks0) -> - DK = #dk{d=Defs,k=cerl_sets:new()}, + DK = #dk{d=Defs,k=sets:new([{version, 2}])}, D0 = #{F=>DK}, Ls = beam_ssa:rpo([F], Blocks0), - Yregs0 = cerl_sets:new(), + Yregs0 = sets:new([{version, 2}]), Yregs = find_yregs_2(Ls, Blocks0, D0, Yregs0), Blk0 = map_get(F, Blocks0), Blk = beam_ssa:add_anno(yregs, Yregs, Blk0), @@ -1848,7 +1848,7 @@ find_update_succ([S|Ss], #dk{d=Defs0,k=Killed0}=DK0, D0) -> case D0 of #{S:=#dk{d=Defs1,k=Killed1}} -> Defs = ordsets:intersection(Defs0, Defs1), - Killed = cerl_sets:union(Killed0, Killed1), + Killed = sets:union(Killed0, Killed1), DK = #dk{d=Defs,k=Killed}, D = D0#{S:=DK}, find_update_succ(Ss, DK0, D); @@ -1860,13 +1860,13 @@ find_update_succ([], _, D) -> D. find_yregs_is([#b_set{dst=Dst}=I|Is], #dk{d=Defs0,k=Killed0}=Ys, Yregs0) -> Yregs1 = intersect_used(I, Killed0), - Yregs = cerl_sets:union(Yregs0, Yregs1), + Yregs = sets:union(Yregs0, Yregs1), case beam_ssa:clobbers_xregs(I) of false -> Defs = ordsets:add_element(Dst, Defs0), find_yregs_is(Is, Ys#dk{d=Defs}, Yregs); true -> - Killed = cerl_sets:union(cerl_sets:from_list(Defs0), Killed0), + Killed = sets:union(sets:from_list(Defs0, [{version, 2}]), Killed0), Defs = [Dst], find_yregs_is(Is, Ys#dk{d=Defs,k=Killed}, Yregs) end; @@ -1874,28 +1874,28 @@ find_yregs_is([], Ys, Yregs) -> {Yregs,Ys}. find_yregs_terminator(Terminator, #dk{k=Killed}, Yregs0) -> Yregs = intersect_used(Terminator, Killed), - cerl_sets:union(Yregs0, Yregs). + sets:union(Yregs0, Yregs). intersect_used(#b_br{bool=#b_var{}=V}, Set) -> intersect_used_keep_singleton(V, Set); intersect_used(#b_ret{arg=#b_var{}=V}, Set) -> intersect_used_keep_singleton(V, Set); intersect_used(#b_set{op=phi,args=Args}, Set) -> - cerl_sets:from_list([V || {#b_var{}=V,_} <- Args, cerl_sets:is_element(V, Set)]); + sets:from_list([V || {#b_var{}=V,_} <- Args, sets:is_element(V, Set)], [{version, 2}]); intersect_used(#b_set{args=Args}, Set) -> - cerl_sets:from_list(intersect_used_keep(used_args(Args), Set)); + sets:from_list(intersect_used_keep(used_args(Args), Set), [{version, 2}]); intersect_used(#b_switch{arg=#b_var{}=V}, Set) -> intersect_used_keep_singleton(V, Set); -intersect_used(_, _) -> cerl_sets:new(). +intersect_used(_, _) -> sets:new([{version, 2}]). intersect_used_keep_singleton(V, Set) -> - case cerl_sets:is_element(V, Set) of - true -> cerl_sets:from_list([V]); - false -> cerl_sets:new() + case sets:is_element(V, Set) of + true -> sets:from_list([V], [{version, 2}]); + false -> sets:new([{version, 2}]) end. intersect_used_keep(Vs, Set) -> - [V || V <- Vs, cerl_sets:is_element(V, Set)]. + [V || V <- Vs, sets:is_element(V, Set)]. used_args([#b_var{}=V|As]) -> [V|used_args(As)]; @@ -1996,8 +1996,8 @@ copy_retval_1([], Blocks, Count) -> collect_yregs([#b_set{op=copy,dst=Y,args=[#b_var{}=X]}|Is], Yregs0) -> - true = cerl_sets:is_element(X, Yregs0), %Assertion. - Yregs = cerl_sets:add_element(Y, cerl_sets:del_element(X, Yregs0)), + true = sets:is_element(X, Yregs0), %Assertion. + Yregs = sets:add_element(Y, sets:del_element(X, Yregs0)), collect_yregs(Is, Yregs); collect_yregs([#b_set{}|Is], Yregs) -> collect_yregs(Is, Yregs); @@ -2042,7 +2042,7 @@ copy_retval_is([#b_set{},#b_set{op=succeeded}]=Is, false, _Yregs, Copy, Count, A copy_retval_is([#b_set{op=Op,dst=#b_var{name=RetName}=Dst}=I0|Is], RC, Yregs, Copy0, Count0, Acc0) when Op =:= call; Op =:= make_fun -> {I1,Count1,Acc} = place_retval_copy(I0, Yregs, Copy0, Count0, Acc0), - case cerl_sets:is_element(Dst, Yregs) of + case sets:is_element(Dst, Yregs) of true -> {NewVar,Count} = new_var(RetName, Count1), Copy = #b_set{op=copy,dst=Dst,args=[NewVar]}, @@ -2100,7 +2100,7 @@ place_retval_copy(#b_set{args=[F|Args0]}=I, Yregs, Copy, Count0, Acc0) -> {I#b_set{args=[F|Args]},Count,Acc}. copy_func_args([#b_var{name=AName}=A|As], Yregs, Avoid, CopyAcc, Acc, Count0) -> - case cerl_sets:is_element(A, Yregs) of + case sets:is_element(A, Yregs) of true when A =/= Avoid -> {NewVar,Count} = new_var(AName, Count0), Copy = #b_set{op=copy,dst=NewVar,args=[A]}, @@ -2402,7 +2402,7 @@ reserve_yregs(#st{frames=Frames}=St0) -> reserve_yregs_1(L, #st{ssa=Blocks0,cnt=Count0,res=Res0}=St) -> Blk = map_get(L, Blocks0), - Yregs = ordsets:from_list(cerl_sets:to_list(beam_ssa:get_anno(yregs, Blk))), + Yregs = ordsets:from_list(sets:to_list(beam_ssa:get_anno(yregs, Blk))), RPO = beam_ssa:rpo([L], Blocks0), {Def,Unused} = beam_ssa:def_unused(RPO, Yregs, Blocks0), UsedYregs = ordsets:subtract(Yregs, Unused), @@ -2592,7 +2592,7 @@ reserve_arg_regs([], _, Acc) -> Acc. reserve_zregs(RPO, Blocks, Intervals, Res) -> ShortLived0 = [V || {V,[{Start,End}]} <- Intervals, Start+2 =:= End], - ShortLived = cerl_sets:from_list(ShortLived0), + ShortLived = sets:from_list(ShortLived0, [{version, 2}]), F = fun(_, #b_blk{is=Is,last=Last}, A) -> reserve_zreg(Is, Last, ShortLived, A) end, @@ -2657,7 +2657,7 @@ use_zreg(_) -> maybe. %% If V is defined just before a branch, we may be able to combine it into a %% test instruction. reserve_test_zreg(#b_var{}=V, ShortLived, A) -> - case cerl_sets:is_element(V, ShortLived) of + case sets:is_element(V, ShortLived) of true -> [{V,z}|A]; false -> A end. diff --git a/lib/compiler/src/beam_ssa_throw.erl b/lib/compiler/src/beam_ssa_throw.erl index 3e0ce49056..fc0d53e6ab 100644 --- a/lib/compiler/src/beam_ssa_throw.erl +++ b/lib/compiler/src/beam_ssa_throw.erl @@ -56,7 +56,7 @@ %% Per-module scan state -record(gst, {tlh_roots :: gb_trees:tree(#b_local{}, gb_sets:set(handler())), tlh_edges=#{} :: #{ #b_local{} => gb_sets:set(#b_local{}) }, - throws=cerl_sets:new() :: cerl_sets:set(#b_local{})}). + throws=sets:new([{version, 2}]) :: sets:set(#b_local{})}). %% Per-function scan state -record(lst, {suitability=#{} :: #{ #b_var{} => suitability() }, @@ -106,7 +106,7 @@ scan_1([], Gst) -> tlh_edges=Edges, throws=Throws} = Gst, - case cerl_sets:size(Throws) of + case sets:size(Throws) of 0 -> no_throws; _ -> @@ -174,7 +174,7 @@ si_is([#b_set{op=call, Id, _Lbl, #b_ret{arg=Dst}, Lst, Gst) -> %% Tail throw, handled by caller. We'll need to visit this function again. #gst{throws=Throws0} = Gst, - Throws = cerl_sets:add_element(Id, Throws0), + Throws = sets:add_element(Id, Throws0), {Lst, Gst#gst{throws=Throws}}; si_is([#b_set{op=call,dst=Dst,args=[#b_local{}=Callee | _]}], Id, _Lbl, #b_ret{arg=Dst}, Lst, Gst) -> @@ -297,7 +297,7 @@ add_tlh(Id, Callee, Lst, Gst) -> opt([#b_function{bs=Blocks0}=F | Fs], Throws, TLHs) -> Id = get_func_id(F), - Blocks = case {cerl_sets:is_element(Id, Throws), TLHs} of + Blocks = case {sets:is_element(Id, Throws), TLHs} of {true, #{ Id := Handlers } } -> opt_function(Handlers, Blocks0); {_, _} -> diff --git a/lib/compiler/src/beam_ssa_type.erl b/lib/compiler/src/beam_ssa_type.erl index 434f90757c..21f3a70b9a 100644 --- a/lib/compiler/src/beam_ssa_type.erl +++ b/lib/compiler/src/beam_ssa_type.erl @@ -60,7 +60,7 @@ { func_id :: func_id(), limit_return :: boolean(), params :: [beam_ssa:b_var()], - used_once :: cerl_sets:set(beam_ssa:b_var()) }). + used_once :: sets:set(beam_ssa:b_var()) }). -type type_db() :: #{ beam_ssa:var_name() := type() }. @@ -1532,7 +1532,7 @@ update_successors(#b_br{bool=#b_literal{val=true},succ=Succ}=Last, {Last, update_successor(Succ, Ts, Ls)}; update_successors(#b_br{bool=#b_var{}=Bool,succ=Succ,fail=Fail}=Last0, Ts, Ds, Ls0, UsedOnce) -> - IsTempVar = cerl_sets:is_element(Bool, UsedOnce), + IsTempVar = sets:is_element(Bool, UsedOnce), case infer_types_br(Bool, Ts, IsTempVar, Ds) of {#{}=SuccTs, #{}=FailTs} -> Ls1 = update_successor(Succ, SuccTs, Ls0), @@ -1547,7 +1547,7 @@ update_successors(#b_br{bool=#b_var{}=Bool,succ=Succ,fail=Fail}=Last0, end; update_successors(#b_switch{arg=#b_var{}=V,fail=Fail0,list=List0}=Last0, Ts, Ds, Ls0, UsedOnce) -> - IsTempVar = cerl_sets:is_element(V, UsedOnce), + IsTempVar = sets:is_element(V, UsedOnce), {List1, FailTs, Ls1} = update_switch(List0, V, raw_type(V, Ts), Ts, Ds, Ls0, IsTempVar, []), @@ -2114,7 +2114,7 @@ gcd(A, B) -> init_metadata(FuncId, Linear, Params) -> {RetCounter, Map0} = init_metadata_1(reverse(Linear), 0, #{}), Map = maps:without(Params, Map0), - UsedOnce = cerl_sets:from_list(maps:keys(Map)), + UsedOnce = sets:from_list(maps:keys(Map), [{version, 2}]), #metadata{ func_id = FuncId, limit_return = (RetCounter >= ?RETURN_LIMIT), diff --git a/lib/compiler/src/beam_trim.erl b/lib/compiler/src/beam_trim.erl index 05e320c255..7dae102181 100644 --- a/lib/compiler/src/beam_trim.erl +++ b/lib/compiler/src/beam_trim.erl @@ -24,7 +24,7 @@ -import(lists, [any/2,member/2,reverse/1,reverse/2,splitwith/2,sort/1]). -record(st, - {safe :: cerl_sets:set(beam_asm:label()) %Safe labels. + {safe :: sets:set(beam_asm:label()) %Safe labels. }). -spec module(beam_utils:module_code(), [compile:option()]) -> @@ -218,14 +218,14 @@ create_map(Trim, []) -> create_map(Trim, Moves) -> Map0 = [{Src,Dst-Trim} || {move,{y,Src},{y,Dst}} <- Moves], Map = maps:from_list(Map0), - IllegalTargets = cerl_sets:from_list([Dst || {move,_,{y,Dst}} <- Moves]), + IllegalTargets = sets:from_list([Dst || {move,_,{y,Dst}} <- Moves], [{version, 2}]), fun({y,Y0}) when Y0 < Trim -> case Map of #{Y0:=Y} -> {y,Y}; #{} -> throw(not_possible) end; ({y,Y}) -> - case cerl_sets:is_element(Y, IllegalTargets) of + case sets:is_element(Y, IllegalTargets) of true -> throw(not_possible); false -> {y,Y-Trim} end; @@ -330,7 +330,7 @@ safe_labels([{label,L}|Is], Acc) -> end; safe_labels([_|Is], Acc) -> safe_labels(Is, Acc); -safe_labels([], Acc) -> cerl_sets:from_list(Acc). +safe_labels([], Acc) -> sets:from_list(Acc, [{version, 2}]). is_safe_label([{'%',_}|Is]) -> is_safe_label(Is); @@ -447,7 +447,7 @@ frame_size(_, _) -> throw(not_possible). frame_size_branch(0, Is, Safe) -> frame_size(Is, Safe); frame_size_branch(L, Is, Safe) -> - case cerl_sets:is_element(L, Safe) of + case sets:is_element(L, Safe) of false -> throw(not_possible); true -> frame_size(Is, Safe) end. diff --git a/lib/compiler/src/beam_validator.erl b/lib/compiler/src/beam_validator.erl index db2cc30e89..4df5c92c13 100644 --- a/lib/compiler/src/beam_validator.erl +++ b/lib/compiler/src/beam_validator.erl @@ -181,7 +181,7 @@ validate_0([{function, Name, Arity, Entry, Code} | Fs], Module, Level, Ft) -> %% A set of all registers containing "fragile" terms. That is, terms %% that don't exist on our process heap and would be destroyed by a %% GC. - fragile=cerl_sets:new() :: cerl_sets:set(), + fragile=sets:new([{version, 2}]) :: sets:set(), %% Number of Y registers. %% %% Note that this may be 0 if there's a frame without saved values, @@ -228,7 +228,7 @@ validate_0([{function, Name, Arity, Entry, Code} | Fs], Module, Level, Ft) -> %% States at labels branched=#{} :: #{ label() => state() }, %% All defined labels - labels=cerl_sets:new() :: cerl_sets:set(), + labels=sets:new([{version, 2}]) :: sets:set(), %% Information of other functions in the module ft=#{} :: #{ label() => map() }, %% Counter for #value_ref{} creation @@ -296,7 +296,7 @@ init_vst({_, _, Arity}, Level, Ft) -> Vst = #vst{branched=#{}, current=#st{}, ft=Ft, - labels=cerl_sets:new(), + labels=sets:new([{version, 2}]), level=Level}, init_function_args(Arity - 1, Vst). @@ -311,7 +311,7 @@ kill_heap_allocation(St) -> validate_branches(MFA, Vst) -> #vst{ branched=Targets0, labels=Labels0 } = Vst, Targets = maps:keys(Targets0), - Labels = cerl_sets:to_list(Labels0), + Labels = sets:to_list(Labels0), case Targets -- Labels of [_|_]=Undef -> Error = {undef_labels, Undef}, @@ -338,7 +338,7 @@ vi({label,Lbl}, #vst{current=St0, {St, Counter} = merge_states(Lbl, St0, Branched0, Counter0), Branched = Branched0#{ Lbl => St }, - Labels = cerl_sets:add_element(Lbl, Labels0), + Labels = sets:add_element(Lbl, Labels0), Vst#vst{current=St, ref_ctr=Counter, @@ -1791,7 +1791,7 @@ heap_alloc_2([], St) -> St. prune_x_regs(Live, #vst{current=St0}=Vst) when is_integer(Live) -> #st{fragile=Fragile0,xs=Xs0} = St0, - Fragile = cerl_sets:filter(fun({x,X}) -> + Fragile = sets:filter(fun({x,X}) -> X < Live; ({y,_}) -> true @@ -1910,7 +1910,7 @@ assert_unique_map_keys([_,_|_]=Ls) -> assert_literal(L), L end || L <- Ls], - case length(Vs) =:= cerl_sets:size(cerl_sets:from_list(Vs)) of + case length(Vs) =:= sets:size(sets:from_list(Vs, [{version, 2}])) of true -> ok; false -> error(keys_not_unique) end. @@ -2749,7 +2749,7 @@ mv_args([], _VsA, _VsB, Acc) -> Acc. merge_fragility(FragileA, FragileB) -> - cerl_sets:union(FragileA, FragileB). + sets:union(FragileA, FragileB). merge_ms_positions(MsPosA, MsPosB, Vs) -> Keys = if @@ -2928,17 +2928,17 @@ set_receive_marker(New, #vst{current=#st{recv_marker=Current}=St0}=Vst) -> %% Marks Reg as fragile. mark_fragile(Reg, Vst) -> #vst{current=#st{fragile=Fragile0}=St0} = Vst, - Fragile = cerl_sets:add_element(Reg, Fragile0), + Fragile = sets:add_element(Reg, Fragile0), St = St0#st{fragile=Fragile}, Vst#vst{current=St}. propagate_fragility(Reg, Args, #vst{current=St0}=Vst) -> #st{fragile=Fragile0} = St0, - Sources = cerl_sets:from_list(Args), - Fragile = case cerl_sets:is_disjoint(Sources, Fragile0) of - true -> cerl_sets:del_element(Reg, Fragile0); - false -> cerl_sets:add_element(Reg, Fragile0) + Sources = sets:from_list(Args, [{version, 2}]), + Fragile = case sets:is_disjoint(Sources, Fragile0) of + true -> sets:del_element(Reg, Fragile0); + false -> sets:add_element(Reg, Fragile0) end, St = St0#st{fragile=Fragile}, @@ -2948,9 +2948,9 @@ propagate_fragility(Reg, Args, #vst{current=St0}=Vst) -> %% a register. remove_fragility(Reg, Vst) -> #vst{current=#st{fragile=Fragile0}=St0} = Vst, - case cerl_sets:is_element(Reg, Fragile0) of + case sets:is_element(Reg, Fragile0) of true -> - Fragile = cerl_sets:del_element(Reg, Fragile0), + Fragile = sets:del_element(Reg, Fragile0), St = St0#st{fragile=Fragile}, Vst#vst{current=St}; false -> @@ -2959,7 +2959,7 @@ remove_fragility(Reg, Vst) -> %% Marks all registers as durable. remove_fragility(#vst{current=St0}=Vst) -> - St = St0#st{fragile=cerl_sets:new()}, + St = St0#st{fragile=sets:new([{version, 2}])}, Vst#vst{current=St}. assert_durable_term(Src, Vst) -> @@ -2969,7 +2969,7 @@ assert_durable_term(Src, Vst) -> assert_not_fragile({Kind,_}=Src, Vst) when Kind =:= x; Kind =:= y -> check_limit(Src), #vst{current=#st{fragile=Fragile}} = Vst, - case cerl_sets:is_element(Src, Fragile) of + case sets:is_element(Src, Fragile) of true -> error({fragile_message_reference, Src}); false -> ok end; diff --git a/lib/compiler/src/sys_core_alias.erl b/lib/compiler/src/sys_core_alias.erl index 9343999980..96259d1530 100644 --- a/lib/compiler/src/sys_core_alias.erl +++ b/lib/compiler/src/sys_core_alias.erl @@ -46,7 +46,7 @@ -define(HAS_SUBS(Sub), Sub#sub.t =/= none). -record(sub, {p=#{} :: #{term() => ?NOTSET | atom()}, %% Found pattern substitutions - v=cerl_sets:new() :: cerl_sets:set(cerl:var_name()), %% Variables used by patterns + v=sets:new([{version, 2}]) :: sets:set(cerl:var_name()), %% Variables used by patterns t=none :: temp()}). %% Temporary information from pre to post -type sub() :: #sub{}. @@ -64,7 +64,7 @@ none | {temp, temp()} | {sub, sub()} - | {clause, [term()], [term()], cerl_sets:set(cerl:var_name()), temp()}. + | {clause, [term()], [term()], sets:set(cerl:var_name()), temp()}. -spec module(cerl:c_module(), [compile:option()]) -> {'ok',cerl:c_module(),[]}. @@ -237,13 +237,13 @@ new_var_name(Key, #sub{p=Pat}=Sub) -> %% merge_variables/2 get_variables(NodesList) -> - cerl_sets:from_list([Var || Node <- NodesList, Var <- cerl_trees:variables(Node)]). + sets:from_list([Var || Node <- NodesList, Var <- cerl_trees:variables(Node)], [{version, 2}]). is_disjoint_variables(Vars1, Vars2) -> - cerl_sets:is_disjoint(Vars1, Vars2). + sets:is_disjoint(Vars1, Vars2). merge_variables(Vars1, Vars2) -> - cerl_sets:union(Vars1, Vars2). + sets:union(Vars1, Vars2). %% get_pattern_keys/2 %% put_pattern_keys/2 diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl index d987c6f3b5..704bddc2ac 100644 --- a/lib/compiler/src/sys_core_fold.erl +++ b/lib/compiler/src/sys_core_fold.erl @@ -95,7 +95,7 @@ %% Variable value info. -record(sub, {v=[], %Variable substitutions - s=cerl_sets:new() :: cerl_sets:set(), %Variables in scope + s=sets:new([{version, 2}]) :: sets:set(), %Variables in scope t=#{} :: map(), %Types in_guard=false}). %In guard or not. @@ -1319,7 +1319,7 @@ is_subst(_) -> false. %% to force renaming if variables in the scope occurs as pattern %% variables. -sub_new() -> #sub{v=orddict:new(),s=cerl_sets:new(),t=#{}}. +sub_new() -> #sub{v=orddict:new(),s=sets:new([{version, 2}]),t=#{}}. sub_new(#sub{}=Sub) -> Sub#sub{v=orddict:new(),t=#{}}. @@ -1336,7 +1336,7 @@ sub_set_var(#c_var{name=V}, Val, Sub) -> sub_set_name(V, Val, #sub{v=S,s=Scope,t=Tdb0}=Sub) -> Tdb1 = kill_types(V, Tdb0), Tdb = copy_type(V, Val, Tdb1), - Sub#sub{v=orddict:store(V, Val, S),s=cerl_sets:add_element(V, Scope),t=Tdb}. + Sub#sub{v=orddict:store(V, Val, S),s=sets:add_element(V, Scope),t=Tdb}. sub_subst_var(#c_var{name=V}, Val, #sub{v=S0}) -> %% Fold chained substitutions. @@ -1344,7 +1344,7 @@ sub_subst_var(#c_var{name=V}, Val, #sub{v=S0}) -> sub_add_scope(Vs, #sub{s=Scope0}=Sub) -> Scope = foldl(fun(V, S) when is_integer(V); is_atom(V) -> - cerl_sets:add_element(V, S) + sets:add_element(V, S) end, Scope0, Vs), Sub#sub{s=Scope}. @@ -1355,7 +1355,7 @@ sub_subst_scope(#sub{v=S0,s=Scope}=Sub) -> _ -> -1 end, - S = sub_subst_scope_1(cerl_sets:to_list(Scope), Initial, S0), + S = sub_subst_scope_1(sets:to_list(Scope), Initial, S0), Sub#sub{v=orddict:from_list(S)}. %% The keys in an orddict must be unique. Make them so! @@ -1364,7 +1364,7 @@ sub_subst_scope_1([H|T], Key, Acc) -> sub_subst_scope_1([], _, Acc) -> Acc. sub_is_in_scope(#c_var{name=V}, #sub{s=Scope}) -> - cerl_sets:is_element(V, Scope). + sets:is_element(V, Scope). %% warn_no_clause_match(CaseOrig, CaseOpt) -> ok %% Generate a warning if none of the user-specified clauses @@ -2116,7 +2116,7 @@ is_bool_expr_list([]) -> true. %% (i.e. it cannot fail). %% is_safe_bool_expr(Core) -> - is_safe_bool_expr_1(Core, cerl_sets:new()). + is_safe_bool_expr_1(Core, sets:new([{version, 2}])). is_safe_bool_expr_1(#c_call{module=#c_literal{val=erlang}, name=#c_literal{val=is_function}, @@ -2146,7 +2146,7 @@ is_safe_bool_expr_1(#c_let{vars=Vars,arg=Arg,body=B}, BoolVars) -> true -> case {is_safe_bool_expr_1(Arg, BoolVars),Vars} of {true,[#c_var{name=V}]} -> - is_safe_bool_expr_1(B, cerl_sets:add_element(V, BoolVars)); + is_safe_bool_expr_1(B, sets:add_element(V, BoolVars)); {false,_} -> is_safe_bool_expr_1(B, BoolVars) end; @@ -2155,7 +2155,7 @@ is_safe_bool_expr_1(#c_let{vars=Vars,arg=Arg,body=B}, BoolVars) -> is_safe_bool_expr_1(#c_literal{val=Val}, _BoolVars) -> is_boolean(Val); is_safe_bool_expr_1(#c_var{name=V}, BoolVars) -> - cerl_sets:is_element(V, BoolVars); + sets:is_element(V, BoolVars); is_safe_bool_expr_1(_, _) -> false. is_safe_bool_expr_list([C|Cs], BoolVars) -> @@ -2228,7 +2228,7 @@ move_let_into_expr(#c_let{vars=Lvs0,body=Lbody0}=Let, B1 = body(B0, ScopeSub), {Lvs,B2,Sub1} = let_substs(Lvs0, B1, Sub0), - Sub2 = Sub1#sub{s=cerl_sets:union(ScopeSub#sub.s, + Sub2 = Sub1#sub{s=sets:union(ScopeSub#sub.s, Sub1#sub.s)}, Lbody = body(Lbody0, Sub2), B = Let#c_let{vars=Lvs, @@ -2488,7 +2488,7 @@ opt_simple_let_1(#c_let{vars=Vs0,body=B0}=Let, Arg0, Ctxt, Sub0) -> %% Optimise let and add new substitutions. {Vs,Args,Sub1} = let_substs(Vs0, Arg0, Sub0), BodySub = update_let_types(Vs, Args, Sub1), - Sub = Sub1#sub{v=[],s=cerl_sets:new()}, + Sub = Sub1#sub{v=[],s=sets:new([{version, 2}])}, B = body(B0, Ctxt, BodySub), Arg = core_lib:make_values(Args), opt_simple_let_2(Let, Vs, Arg, B, B0, Sub). @@ -2865,12 +2865,12 @@ verify_scope(E, #sub{s=Scope}) -> false -> io:format("~p\n", [E]), io:format("~p\n", [Free]), - io:format("~p\n", [ordsets:from_list(cerl_sets:to_list(Scope))]), + io:format("~p\n", [ordsets:from_list(sets:to_list(Scope))]), false end. is_subset_of_scope([V|Vs], Scope) -> - cerl_sets:is_element(V, Scope) andalso is_subset_of_scope(Vs, Scope); + sets:is_element(V, Scope) andalso is_subset_of_scope(Vs, Scope); is_subset_of_scope([], _) -> true. -endif. diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl index fa54a14067..e8576913b3 100644 --- a/lib/compiler/src/v3_core.erl +++ b/lib/compiler/src/v3_core.erl @@ -938,7 +938,7 @@ badmap_term(Map, #core{in_guard=false}) -> c_tuple([#c_literal{val=badmap},Map]). map_build_pairs(Map, Es0, Ann, St0) -> - {Es,Pre,_,St1} = map_build_pairs_1(Es0, cerl_sets:new(), St0), + {Es,Pre,_,St1} = map_build_pairs_1(Es0, sets:new([{version, 2}]), St0), {ann_c_map(Ann, Map, Es),Pre,St1}. map_build_pairs_1([{Op0,L,K0,V0}|Es], Used0, St0) -> @@ -958,11 +958,11 @@ maybe_warn_repeated_keys(Ck,Line,Used,St) -> false -> {Used,St}; true -> K = cerl:concrete(Ck), - case cerl_sets:is_element(K,Used) of + case sets:is_element(K,Used) of true -> {Used, add_warning(Line, {map_key_repeated,K}, St)}; false -> - {cerl_sets:add_element(K,Used), St} + {sets:add_element(K,Used), St} end end. diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl index be7f9824fb..eb04a2c916 100644 --- a/lib/compiler/src/v3_kernel.erl +++ b/lib/compiler/src/v3_kernel.erl @@ -115,12 +115,12 @@ copy_anno(Kdst, Ksrc) -> fargs=[] :: [#k_var{}], %Arguments for current function vcount=0, %Variable counter fcount=0, %Fun counter - ds=cerl_sets:new() :: cerl_sets:set(), %Defined variables + ds=sets:new([{version, 2}]) :: sets:set(), %Defined variables funs=[], %Fun functions free=#{}, %Free variables ws=[] :: [warning()], %Warnings. no_shared_fun_wrappers=false :: boolean(), - labels=cerl_sets:new() + labels=sets:new([{version, 2}]) }). -spec module(cerl:c_module(), [compile:option()]) -> @@ -165,7 +165,7 @@ function({#c_var{name={F,Arity}=FA},Body}, St0) -> %% the function. We use integers as variable names to avoid %% filling up the atom table when compiling huge functions. Count = cerl_trees:next_free_variable_name(Body), - St1 = St0#kern{func=FA,vcount=Count,fcount=0,ds=cerl_sets:new()}, + St1 = St0#kern{func=FA,vcount=Count,fcount=0,ds=sets:new([{version, 2}])}, {#ifun{anno=Ab,vars=Kvs,body=B0},[],St2} = expr(Body, new_sub(), St1), {B1,_,St3} = ubody(B0, return, St2), %%B1 = B0, St3 = St2, %Null second pass @@ -394,7 +394,7 @@ letrec_local_function(A, Cfs, Cb, Sub0, St0) -> letrec_goto([{#c_var{name={Label,0}},Cfail}], Cb, Sub0, #kern{labels=Labels0}=St0) -> - Labels = cerl_sets:add_element(Label, Labels0), + Labels = sets:add_element(Label, Labels0), {Kb,Pb,St1} = body(Cb, Sub0, St0#kern{labels=Labels}), #c_fun{body=FailBody} = Cfail, {Kfail,Fb,St2} = body(FailBody, Sub0, St1), @@ -559,7 +559,7 @@ match_vars(Ka, St0) -> %% Transform application. c_apply(A, #c_var{anno=Ra,name={F0,Ar}}, Cargs, Sub, #kern{labels=Labels}=St0) -> - case Ar =:= 0 andalso cerl_sets:is_element(F0, Labels) of + case Ar =:= 0 andalso sets:is_element(F0, Labels) of true -> %% This is a goto to a label in a letrec_goto construct. {#k_goto{label=F0},[],St0}; @@ -666,15 +666,15 @@ force_variable(Ke, St0) -> %% handling. pattern(#c_var{anno=A,name=V}, _Isub, Osub, St0) -> - case cerl_sets:is_element(V, St0#kern.ds) of + case sets:is_element(V, St0#kern.ds) of true -> {New,St1} = new_var_name(St0), {#k_var{anno=A,name=New}, set_vsub(V, New, Osub), - St1#kern{ds=cerl_sets:add_element(New, St1#kern.ds)}}; + St1#kern{ds=sets:add_element(New, St1#kern.ds)}}; false -> {#k_var{anno=A,name=V},Osub, - St0#kern{ds=cerl_sets:add_element(V, St0#kern.ds)}} + St0#kern{ds=sets:add_element(V, St0#kern.ds)}} end; pattern(#c_literal{anno=A,val=Val}, _Isub, Osub, St) -> {#k_literal{anno=A,val=Val},Osub,St}; @@ -1446,7 +1446,7 @@ partition_intersection(_, Us, Cs, St) -> partition_keys(#k_map{es=Pairs}=Map, Ks) -> F = fun(#k_map_pair{key=Key}) -> - cerl_sets:is_element(map_key_clean(Key), Ks) + sets:is_element(map_key_clean(Key), Ks) end, {Ps1,Ps2} = partition(F, Pairs), {Map#k_map{es=Ps1},Map#k_map{es=Ps2}}; @@ -1456,9 +1456,9 @@ partition_keys(#ialias{pat=Map}=Alias, Ks) -> {Map1,Alias#ialias{pat=Map2}}. find_key_intersection(Ps) -> - Sets = [cerl_sets:from_list(Ks) || Ks <- Ps], - Intersection = cerl_sets:intersection(Sets), - case cerl_sets:size(Intersection) of + Sets = [sets:from_list(Ks, [{version, 2}]) || Ks <- Ps], + Intersection = sets:intersection(Sets), + case sets:size(Intersection) of 0 -> none; _ -> -- 2.26.2
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
