Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
home:Ledest:erlang:23
erlang
2743-v3_core-Raise-clearer-exceptions-when-gene...
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File 2743-v3_core-Raise-clearer-exceptions-when-generators-are.patch of Package erlang
From a6ecaf8b937449b6f6de67efaee6b2460fffc8ec Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org> Date: Fri, 6 Nov 2020 07:36:50 +0100 Subject: [PATCH 3/5] v3_core: Raise clearer exceptions when generators are bad Raise a `{bad_generator,Generator}` exception when a generator is bad instead of some ad-hoc exception. To implement this in a clean way, the calculation of size of binary comprehension will be moved out of `v3_core` and into a new SSA-based pass. --- lib/compiler/src/Makefile | 1 + lib/compiler/src/beam_kernel_to_ssa.erl | 22 +- lib/compiler/src/beam_ssa_bc_size.erl | 593 ++++++++++++++++++++++++ lib/compiler/src/beam_ssa_opt.erl | 7 +- lib/compiler/src/beam_ssa_type.erl | 22 +- lib/compiler/src/beam_types.erl | 6 + lib/compiler/src/cerl_inline.erl | 5 +- lib/compiler/src/compile.erl | 1 + lib/compiler/src/compiler.app.src | 1 + lib/compiler/src/v3_core.erl | 280 ++--------- lib/compiler/test/beam_except_SUITE.erl | 2 +- lib/compiler/test/bs_bincomp_SUITE.erl | 101 +++- lib/compiler/test/lc_SUITE.erl | 36 +- lib/compiler/test/misc_SUITE.erl | 12 + 14 files changed, 787 insertions(+), 302 deletions(-) create mode 100644 lib/compiler/src/beam_ssa_bc_size.erl diff --git a/lib/compiler/src/Makefile b/lib/compiler/src/Makefile index 712f795601..f4600c35f8 100644 --- a/lib/compiler/src/Makefile +++ b/lib/compiler/src/Makefile @@ -60,6 +60,7 @@ MODULES = \ beam_opcodes \ beam_peep \ beam_ssa \ + beam_ssa_bc_size \ beam_ssa_bool \ beam_ssa_bsm \ beam_ssa_codegen \ diff --git a/lib/compiler/src/beam_kernel_to_ssa.erl b/lib/compiler/src/beam_kernel_to_ssa.erl index 43834cb145..b4ba15a7d3 100644 --- a/lib/compiler/src/beam_kernel_to_ssa.erl +++ b/lib/compiler/src/beam_kernel_to_ssa.erl @@ -697,8 +697,8 @@ enter_cg(Func, As0, Le, St0) -> %% 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, St); +bif_cg(#k_bif{anno=A,op=#k_internal{name=Name},args=As,ret=Rs}, _Le, St) -> + internal_cg(line_anno(A), Name, As, Rs, St); bif_cg(#k_bif{op=#k_remote{mod=#k_literal{val=erlang},name=#k_literal{val=Name}}, args=As,ret=Rs}, Le, St) -> bif_cg(Name, As, Rs, Le, St). @@ -706,7 +706,7 @@ bif_cg(#k_bif{op=#k_remote{mod=#k_literal{val=erlang},name=#k_literal{val=Name}} %% internal_cg(Bif, [Arg], [Ret], Le, State) -> %% {[Ainstr],State}. -internal_cg(raise, As, [#k_var{name=Dst0}], St0) -> +internal_cg(_Anno, raise, As, [#k_var{name=Dst0}], St0) -> Args = ssa_args(As, St0), {Dst,St} = new_ssa_var(Dst0, St0), Resume = #b_set{op=resume,dst=Dst,args=Args}, @@ -724,13 +724,13 @@ internal_cg(raise, As, [#k_var{name=Dst0}], St0) -> Is = [Resume,make_uncond_branch(Fail),#cg_unreachable{}], {Is,St} end; -internal_cg(recv_peek_message, [], [#k_var{name=Succeeded0}, - #k_var{name=Dst0}], St0) -> +internal_cg(_Anno, recv_peek_message, [], [#k_var{name=Succeeded0}, + #k_var{name=Dst0}], St0) -> {Dst,St1} = new_ssa_var(Dst0, St0), St = new_succeeded_value(Succeeded0, Dst, St1), Set = #b_set{op=peek_message,dst=Dst,args=[]}, {[Set],St}; -internal_cg(recv_wait_timeout, As, [#k_var{name=Succeeded0}], St0) -> +internal_cg(_Anno, recv_wait_timeout, As, [#k_var{name=Succeeded0}], St0) -> case ssa_args(As, St0) of [#b_literal{val=0}] -> %% If beam_ssa_opt is run (which is default), the @@ -771,17 +771,17 @@ internal_cg(recv_wait_timeout, As, [#k_var{name=Succeeded0}], St0) -> Set = #b_set{op=wait_timeout,dst=Wait,args=Args}, {[Set|Succ],St} end; -internal_cg(Op, As, [#k_var{name=Dst0}], St0) when is_atom(Op) -> +internal_cg(Anno, Op, As, [#k_var{name=Dst0}], St0) when is_atom(Op) -> %% This behaves like a function call. {Dst,St} = new_ssa_var(Dst0, St0), Args = ssa_args(As, St), - Set = #b_set{op=Op,dst=Dst,args=Args}, + Set = #b_set{anno=Anno,op=Op,dst=Dst,args=Args}, {[Set],St}; -internal_cg(Op, As, [], St0) when is_atom(Op) -> +internal_cg(Anno, Op, As, [], St0) when is_atom(Op) -> %% This behaves like a function call. {Dst,St} = new_ssa_var('@ssa_ignored', St0), Args = ssa_args(As, St), - Set = #b_set{op=Op,dst=Dst,args=Args}, + Set = #b_set{anno=Anno,op=Op,dst=Dst,args=Args}, {[Set],St}. bif_cg(Bif, As0, [#k_var{name=Dst0}], Le, St0) -> @@ -1153,6 +1153,8 @@ cg_size_bif({Name,Src}, FailCtx, St0) -> cg_size_add(#b_literal{val=0}, Val, #b_literal{val=1}, _FailCtx, St) -> {Val,[],St}; +cg_size_add(#b_literal{val=A}, #b_literal{val=B}, #b_literal{val=U}, _FailCtx, St) -> + {#b_literal{val=A+B*U},[],St}; cg_size_add(A, B, Unit, FailCtx, St0) -> {Dst,St1} = new_ssa_var('@ssa_sum', St0), {TestIs,St} = make_succeeded(Dst, FailCtx, St1), diff --git a/lib/compiler/src/beam_ssa_bc_size.erl b/lib/compiler/src/beam_ssa_bc_size.erl new file mode 100644 index 0000000000..2c3be55bc6 --- /dev/null +++ b/lib/compiler/src/beam_ssa_bc_size.erl @@ -0,0 +1,593 @@ +%% +%% %CopyrightBegin% +%% +%% Copyright Ericsson AB 2020. 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% +%% +%% Try to calculate the exact size of bitstring produced by a binary +%% comprehension such as: +%% +%% << <<X:16>> || <<X:4>> <= Bs >> +%% +%% For this example, the size of the resulting binary (rounded up to +%% the nearest number of bytes) will be: +%% +%% ((bit_size(Bs) div 4) * 16 + 7) div 8 +%% +%% If the exact size can't be determined, such as for this comprehension: +%% +%% << <<X:16>> || <<X:4>> <= Bs, X =/= 15 >> +%% +%% the default size of 256 bytes will be used as starting size of +%% the writable binary. +%% + +-module(beam_ssa_bc_size). +-export([opt/1]). + +-import(lists, [any/2,reverse/1,sort/1]). + +-include("beam_ssa_opt.hrl"). + +-spec opt(st_map()) -> st_map(). + +opt(StMap) -> + opt(maps:keys(StMap), StMap). + +opt([Id|Ids], StMap0) -> + StMap = opt_function(Id, StMap0), + opt(Ids, StMap); +opt([], StMap) -> StMap. + +opt_function(Id, StMap) -> + #opt_st{ssa=Linear0,cnt=Count0} = OptSt0 = map_get(Id, StMap), + try opt_blks(Linear0, StMap, unchanged, Count0, []) of + {Linear,Count} -> + OptSt = OptSt0#opt_st{ssa=Linear,cnt=Count}, + StMap#{Id := OptSt}; + none -> + StMap + catch + Class:Error:Stack -> + #b_local{name=#b_literal{val=Name},arity=Arity} = Id, + io:fwrite("Function: ~w/~w\n", [Name,Arity]), + erlang:raise(Class, Error, Stack) + end. + +opt_blks([{L,#b_blk{is=Is}=Blk}|Blks], StMap, AnyChange, Count0, Acc0) -> + case Is of + [#b_set{op=bs_init_writable,dst=Dst}] -> + Bs = #{st_map => StMap, Dst => {writable,#b_literal{val=0}}}, + try opt_writable(Bs, L, Blk, Blks, Count0, Acc0) of + {Acc,Count} -> + opt_blks(Blks, StMap, changed, Count, Acc) + catch + throw:not_possible -> + opt_blks(Blks, StMap, AnyChange, Count0, [{L,Blk}|Acc0]) + end; + _ -> + opt_blks(Blks, StMap, AnyChange, Count0, [{L,Blk}|Acc0]) + end; +opt_blks([], _StMap, changed, Count, Acc) -> + {reverse(Acc),Count}; +opt_blks([], _StMap, unchanged, _Count, _Acc) -> + none. + +opt_writable(Bs0, L, Blk, Blks, Count0, Acc0) -> + case {Blk,Blks} of + {#b_blk{last=#b_br{succ=Next,fail=Next}}, + [{Next,#b_blk{is=[#b_set{op=call,args=[_|Args],dst=Dst}=Call|_]}}|_]} -> + ArgTypes = maps:from_list([{Arg,{arg,Arg}} || Arg <- Args]), + Bs = maps:merge(ArgTypes, Bs0), + Result = map_get(Dst, call_size_func(Call, Bs)), + {Expr,Annos} = make_expr_tree(Result), + cg_size_calc(Expr, L, Blk, Annos, Count0, Acc0); + {_,_} -> + throw(not_possible) + end. + +%%% +%%% Traverse the SSA code of the binary comprehension functions to +%%% figure out the exact size for the writable binary. This algorithm +%%% is similar to how types are determined by beam_ssa_type, but here +%%% we only care about how many bits are matched of from the generators +%%% and how many bits are appended to the writable binary. +%%% + +call_size_func(#b_set{anno=Anno,op=call,args=[Name|Args],dst=Dst}, Bs) -> + StMap = map_get(st_map, Bs), + case StMap of + #{Name := #opt_st{ssa=Linear,args=Params}} -> + NewBs0 = setup_call_bs(Params, Args, Bs, #{}), + case any(fun({writable,_}) -> true; + (_) -> false + end, maps:values(NewBs0)) of + false -> + %% Since the writable binary is not passed to the called function, + %% it can't have any effect on the size of the writable binary + %% and there is no need to analyze it. + Bs#{Dst => any}; + true -> + NewBs = NewBs0#{Name => self, st_map => StMap}, + Map0 = #{0 => NewBs}, + Result = calc_size(Linear, Map0), + Bs#{Dst => Result} + end; + #{} -> + case Name of + #b_remote{mod=#b_literal{val=erlang}, + name=#b_literal{val=error}, + arity=1} -> + capture_anno(Anno, Dst, Args, Bs#{Dst => exception}); + _ -> + Bs#{Dst => any} + end + end. + +capture_anno(Anno, Dst, [ErrorTerm], Bs) -> + case get_value(ErrorTerm, Bs) of + {tuple,Elements} -> + Ts = [get_value(E, Bs) || E <- Elements], + capture_anno_1(Anno, Dst, Ts, Bs); + _ -> + Bs + end. + +capture_anno_1(Anno, Dst, [{nil_or_bad,Generator}|_], Bs) -> + Bs#{Dst => {generator_anno,{Generator,Anno}}}; +capture_anno_1(Anno, Dst, [{arg,Generator}|_], Bs) -> + Bs#{Dst => {generator_anno,{Generator,Anno}}}; +capture_anno_1(Anno, Dst, [_|T], Bs) -> + capture_anno_1(Anno, Dst, T, Bs); +capture_anno_1(_, _, [], Bs) -> + Bs. + +setup_call_bs([V|Vs], [A0|As], OldBs, NewBs) -> + A = case get_value(A0, OldBs) of + #b_literal{}=Lit -> {arg,Lit}; + {writable,#b_literal{val=0}}=Wr -> Wr; + {arg,_}=Arg -> Arg; + _ -> any + end, + setup_call_bs(Vs, As, OldBs, NewBs#{V => A}); +setup_call_bs([], [], #{}, NewBs) -> NewBs. + +calc_size([{L,#b_blk{is=Is,last=Last}}|Blks], Map0) -> + case maps:take(L, Map0) of + {Bs0,Map1} -> + Bs1 = calc_size_is(Is, Bs0), + Map2 = update_successors(Last, Bs1, Map1), + case get_ret(Last, Bs1) of + none -> + calc_size(Blks, Map2); + Ret -> + %% Save information about the function returned. + Map = Map2#{L => Ret}, + calc_size(Blks, Map) + end; + error -> + %% This block is unreachable. + calc_size(Blks, Map0) + end; +calc_size([], Map) -> + case sort(maps:values(Map)) of + [{call,_}=Call,{generator_anno,GenAnno}] -> + {Call,GenAnno}; + _ -> + throw(not_possible) + end. + +get_ret(#b_ret{arg=Arg}, Bs) -> + case get_value(Arg, Bs) of + exception -> + none; + {writable,#b_literal{val=0}} -> + none; + {generator_anno,_}=GenAnno -> + GenAnno; + Ret -> + Ret + end; +get_ret(_, _) -> none. + +update_successors(#b_br{bool=Bool,succ=Succ,fail=Fail}, Bs0, Map0) -> + case get_value(Bool, Bs0) of + #b_literal{val=true} -> + update_successor(Succ, Bs0, Map0); + {succeeded,Var} -> + Map = update_successor(Succ, Bs0, Map0), + update_successor(Fail, maps:remove(Var, Bs0), Map); + {'if',Var,TrueType,FalseType} -> + Bs = maps:remove(Bool, Bs0), + Map = update_successor(Succ, Bs#{Var => TrueType}, Map0), + update_successor(Fail, Bs#{Var => FalseType}, Map); + any -> + Map = update_successor(Succ, Bs0#{Bool := #b_literal{val=true}}, Map0), + update_successor(Fail, Bs0#{Bool := #b_literal{val=false}}, Map) + end; +update_successors(#b_switch{}, _Bs, _Map) -> + %% A switch implies a filter, which means that we cannot calculate the + %% exact size. + throw(not_possible); +update_successors(#b_ret{}, _Bs, Map) -> Map. + +update_successor(?EXCEPTION_BLOCK, _Bs, Map) -> + Map; +update_successor(L, Bs, Map) -> + case Map of + #{L := OldBs} -> + Map#{L := join_bs(OldBs, Bs)}; + #{} -> + Map#{L => Bs} + end. + +calc_size_is([I|Is], Bs0) -> + Bs = calc_size_instr(I, Bs0), + calc_size_is(Is, Bs); +calc_size_is([], Bs) -> Bs. + +calc_size_instr(#b_set{op=bs_add,args=[A,B,U],dst=Dst}, Bs) -> + %% We must make sure that the value of bs_add only depends on literals + %% and arguments passed from the function that created the writable + %% binary. + case {get_value(A, Bs),get_arg_value(B, Bs)} of + {#b_literal{}=Lit,Val} -> + Bs#{Dst => {expr,{{bif,'+'},[Lit,{{bif,'*'},[Val,U]}]}}}; + {{expr,Expr},Val} -> + Bs#{Dst => {expr,{{bif,'+'},[Expr,{{bif,'*'},[Val,U]}]}}}; + {_,_} -> + %% The value depends on a variable of which we know nothing. + Bs#{Dst => any} + end; +calc_size_instr(#b_set{op=bs_init,args=[#b_literal{val=private_append}, + Writable,Size,Unit], + dst=Dst}, Bs) -> + case get_value(Size, Bs) of + {arg,SizeOrigin} -> + Expr = {{bif,'*'},[SizeOrigin,Unit]}, + update_writable(Dst, Writable, Expr, Bs); + #b_literal{} -> + Expr = {{bif,'*'},[Size,Unit]}, + update_writable(Dst, Writable, Expr, Bs); + {expr,Expr} -> + update_writable(Dst, Writable, Expr, Bs); + _ -> + Bs#{Dst => any} + end; +calc_size_instr(#b_set{op=bs_match,args=[_Type,Ctx,_Flags, + Size,Unit],dst=Dst}, Bs) -> + case get_arg_value(Size, Bs) of + none -> + Bs#{Dst => any}; + Val -> + update_match(Dst, Ctx, {{safe,{bif,'*'}},[Val,Unit]}, Bs) + end; +calc_size_instr(#b_set{op=bs_start_match,args=[#b_literal{val=new},Arg],dst=Dst}, Bs) -> + case get_arg_value(Arg, Bs) of + none -> + Bs#{Dst => any}; + Val -> + Bs#{Dst => {match,{{bif,bit_size},[Val]},#b_literal{val=0}}} + end; +calc_size_instr(#b_set{op=call,args=[Name|Args],dst=Dst}=I, Bs) -> + if + is_map_key(Name, Bs) -> + Result0 = [get_value(A, Bs) || A <- Args], + Result = [Val || Val <- Result0, Val =/= any], + Bs#{Dst => {call,Result}}; + true -> + call_size_func(I, Bs) + end; +calc_size_instr(#b_set{op=get_tl,args=[Ctx],dst=Dst}, Bs) -> + update_match(Dst, Ctx, #b_literal{val=1}, Bs); +calc_size_instr(#b_set{op=is_nonempty_list,args=[Arg],dst=Dst}, Bs) -> + case get_arg_value(Arg, Bs) of + none -> + Bs#{Dst => any}; + Val -> + NumElements = {{bif,length},[Val]}, + Match = {match,NumElements,#b_literal{val=0}}, + NoMatch = {nil_or_bad,Val}, + Bs#{Dst => {'if',Arg,Match,NoMatch}} + end; +calc_size_instr(#b_set{op=put_tuple,args=Args,dst=Dst}, Bs) -> + Bs#{Dst => {tuple,Args}}; +calc_size_instr(#b_set{op={succeeded,_},args=[Arg],dst=Dst}, Bs) -> + Bs#{Dst => {succeeded,Arg}}; +calc_size_instr(#b_set{dst=Dst}, Bs) -> + Bs#{Dst => any}. + +update_writable(Dst, Writable, Expr, Bs) -> + case get_value(Writable, Bs) of + {writable,#b_literal{val=0}} -> + Bs#{Dst => {writable,Expr}}; + _ -> + Bs#{Dst => any} + end. + +update_match(Dst, Ctx, Increment, Bs) -> + case get_value(Ctx, Bs) of + {match,NumElements,Offset0} -> + Offset = {{bif,'+'},[Offset0,Increment]}, + Bs#{Dst => {match,NumElements,Offset}}; + _ -> + Bs#{Dst => any} + end. + +get_arg_value(#b_literal{}=Lit, _Bs) -> + Lit; +get_arg_value(Name, Bs) -> + case Bs of + #{Name := {arg,Val}} -> Val; + #{} -> none + end. + +get_value(Name, Bs) -> + case Bs of + #{Name := Value} -> Value; + #{} -> Name + end. + +join_bs(LHS, RHS) -> + if + map_size(LHS) < map_size(RHS) -> + join_bs_1(maps:keys(LHS), RHS, LHS); + true -> + join_bs_1(maps:keys(RHS), LHS, RHS) + end. + +%% Joins two maps of bindings, keeping the variables that are common to both maps. +join_bs_1([V | Vs], Bigger, Smaller) -> + case {Bigger, Smaller} of + {#{V := Same},#{V := Same}} -> + join_bs_1(Vs, Bigger, Smaller); + {#{V := _LHS},#{V := _RHS}} -> + join_bs_1(Vs, Bigger, Smaller#{V := any}); + {#{}, #{V := _}} -> + join_bs_1(Vs, Bigger, maps:remove(V, Smaller)) + end; +join_bs_1([], _Bigger, Smaller) -> Smaller. + +%%% +%%% Turn the result of the traversal of the SSA code into an expression tree. +%%% + +make_expr_tree({{call,Alloc0},GenAnno}) -> + {Alloc1,Annos} = make_expr_tree_list(Alloc0, none, none, [GenAnno]), + Alloc2 = opt_expr(Alloc1), + Alloc = round_up_to_byte_size(Alloc2), + {Alloc,maps:from_list(Annos)}; +make_expr_tree(_) -> + throw(not_possible). + +make_expr_tree_list([{{call,List},GenAnno}|T], Match, none, Annos0) -> + {BuildSize,Annos} = make_expr_tree_list(List, none, none, [GenAnno|Annos0]), + make_expr_tree_list(T, Match, BuildSize, Annos); +make_expr_tree_list([{match,NumItems,N}|T], none, BuildSize, Annos) -> + make_expr_tree_list(T, {NumItems,N}, BuildSize, Annos); +make_expr_tree_list([{writable,BuildSize}|T], Match, none, Annos) -> + make_expr_tree_list(T, Match, BuildSize, Annos); +make_expr_tree_list([_|T], Match, BuildSize, Annos) -> + make_expr_tree_list(T, Match, BuildSize, Annos); +make_expr_tree_list([], Match, BuildSize, Annos) + when Match =/= none, BuildSize =/= none -> + {NumItems,N} = Match, + Expr = {{bif,'*'},[{{safe,{bif,'div'}},[NumItems,N]},BuildSize]}, + {Expr,Annos}; +make_expr_tree_list([], _, _, Annos) -> + {none,Annos}. + +round_up_to_byte_size(Alloc0) -> + Alloc = case divisible_by_eight(Alloc0) of + true -> Alloc0; + false -> {{bif,'+'},[Alloc0,#b_literal{val=7}]} + end, + opt_expr({{bif,'div'},[Alloc,#b_literal{val=8}]}). + +divisible_by_eight({{bif,'*'},[Expr1,Expr2]}) -> + divisible_by_eight(Expr1) orelse divisible_by_eight(Expr2); +divisible_by_eight(#b_literal{val=Val}) when Val rem 8 =:= 0 -> + true; +divisible_by_eight(_) -> false. + +%%% +%%% Optimize an expression tree. +%%% + +opt_expr({Op,Args0}) -> + Args = opt_expr_args(Args0), + case literal_expr_args(Args, []) of + none -> + opt_expr_1(Op, Args); + LitArgs -> + Bif = case Op of + {safe,{bif,Bif0}} -> Bif0; + {bif,Bif0} -> Bif0 + end, + try apply(erlang, Bif, LitArgs) of + Result -> + #b_literal{val=Result} + catch + error:_ -> + opt_expr_1(Op, Args) + end + end; +opt_expr(none) -> none. + +opt_expr_1({safe,{bif,'div'}}=Op, Args) -> + case Args of + [Int,#b_literal{val=1}] -> + Int; + [_Int,#b_literal{val=N}] when N > 1 -> + opt_expr_1({bif,'div'}, Args); + [_,_] -> + {Op,Args} + end; +opt_expr_1({bif,'div'}=Op, [Numerator,#b_literal{val=Denominator}]=Args) -> + try + opt_expr_div(Numerator, Denominator) + catch + throw:not_possible -> + case Denominator band (Denominator - 1) of + 0 -> + %% The denominator is a power of two. + Shift = round(math:log2(Denominator)), + {{bif,'bsr'},[Numerator,#b_literal{val=Shift}]}; + _ -> + {Op,Args} + end + end; +opt_expr_1({bif,'*'}, [{{safe,_},_},#b_literal{val=0}=Zero]) -> + Zero; +opt_expr_1({bif,'*'}, [Factor,#b_literal{val=1}]) -> + Factor; +opt_expr_1(Op, Args) -> + {Op,Args}. + +opt_expr_div({{bif,'*'},[A,B]}, Denominator) -> + case B of + #b_literal{val=Factor} when Factor rem Denominator =:= 0 -> + {{bif,'*'},[A,#b_literal{val=Factor div Denominator}]}; + _ -> + {{bif,'*'},[A,opt_expr_div(B, Denominator)]} + end; +opt_expr_div(_, _) -> + throw(not_possible). + +opt_expr_args([A0|As]) -> + A = case A0 of + #b_literal{} -> A0; + #b_var{} -> A0; + _ -> opt_expr(A0) + end, + [A|opt_expr_args(As)]; +opt_expr_args([]) -> []. + +literal_expr_args([#b_literal{val=Val}|As], Acc) -> + literal_expr_args(As, [Val|Acc]); +literal_expr_args([_|_], _) -> + none; +literal_expr_args([], Acc) -> + reverse(Acc). + +%%% +%%% Given an expression tree, generate SSA code to calculate the number +%%% bytes to allocate for the writable binary. +%%% + +cg_size_calc(Expr, L, #b_blk{is=Is0}=Blk0, Annos, Count0, Acc0) -> + [InitWr] = Is0, + FailBlk0 = [], + {Acc1,Alloc,NextBlk,FailBlk,Count} = cg_size_calc_1(L, Expr, Annos, FailBlk0, Count0, Acc0), + Is = [InitWr#b_set{args=[Alloc]}], + Blk = Blk0#b_blk{is=Is}, + Acc = [{NextBlk,Blk}|FailBlk++Acc1], + {Acc,Count}. + +cg_size_calc_1(L, #b_literal{}=Alloc, _Annos, FailBlk, Count, Acc) -> + {Acc,Alloc,L,FailBlk,Count}; +cg_size_calc_1(L0, {Op0,Args0}, Annos, FailBlk0, Count0, Acc0) -> + {Args,Acc1,L,FailBlk1,Count1} = cg_atomic_args(Args0, L0, Annos, FailBlk0, Count0, Acc0, []), + {BadGenL,FailBlk,Count2} = cg_bad_generator(Args, Annos, FailBlk1, Count1), + {Dst,Count3} = new_var('@ssa_tmp', Count2), + case Op0 of + {safe,Op} -> + {OpDst,Count4} = new_var('@ssa_size', Count3), + {[OpSuccL,OpFailL,PhiL,NextL],Count5} = new_blocks(4, Count4), + I = #b_set{op=Op,args=Args,dst=OpDst}, + {Blk,Count} = cg_succeeded(I, OpSuccL, OpFailL, Count5), + JumpBlk = #b_blk{is=[],last=cg_br(PhiL)}, + PhiIs = [#b_set{op=phi, + args=[{OpDst,OpSuccL},{#b_literal{val=0},OpFailL}], + dst=Dst}], + PhiBlk = #b_blk{is=PhiIs,last=cg_br(NextL)}, + Acc = [{PhiL,PhiBlk},{OpSuccL,JumpBlk}, + {OpFailL,JumpBlk},{L,Blk}|Acc1], + {Acc,Dst,NextL,FailBlk,Count}; + _ -> + {NextBlkL,Count4} = new_block(Count3), + I = #b_set{op=Op0,args=Args,dst=Dst}, + {SuccBlk,Count} = cg_succeeded(I, NextBlkL, BadGenL, Count4), + Acc = [{L,SuccBlk}|Acc1], + {Acc,Dst,NextBlkL,FailBlk,Count} + end. + +cg_bad_generator([Arg|_], Annos, FailBlk, Count) -> + case Annos of + #{Arg := Anno} -> + cg_bad_generator_1(Anno, Arg, FailBlk, Count); + #{} -> + case FailBlk of + [{L,_}|_] -> + {L,FailBlk,Count}; + [] -> + cg_bad_generator_1(#{}, Arg, FailBlk, Count) + end + end. + +cg_bad_generator_1(Anno, Arg, FailBlk, Count0) -> + {L,Count1} = new_block(Count0), + {TupleDst,Count2} = new_var('@ssa_tuple', Count1), + {Ret,Count3} = new_var('@ssa_ret', Count2), + MFA = #b_remote{mod=#b_literal{val=erlang}, + name=#b_literal{val=error}, + arity=1}, + TupleI = #b_set{op=put_tuple, + args=[#b_literal{val=bad_generator},Arg], + dst=TupleDst}, + CallI = #b_set{anno=Anno,op=call,args=[MFA,TupleDst],dst=Ret}, + Is = [TupleI,CallI], + Blk = #b_blk{is=Is,last=#b_ret{arg=Ret}}, + {L,[{L,Blk}|FailBlk],Count3}. + +cg_succeeded(#b_set{dst=OpDst}=I, Succ, Fail, Count0) -> + {Bool,Count} = new_var('@ssa_bool', Count0), + SuccI = #b_set{op={succeeded,guard},args=[OpDst],dst=Bool}, + Blk = #b_blk{is=[I,SuccI],last=#b_br{bool=Bool,succ=Succ,fail=Fail}}, + {Blk,Count}. + +cg_br(Target) -> + #b_br{bool=#b_literal{val=true},succ=Target,fail=Target}. + +cg_atomic_args([A|As], L, Annos, FailBlk0, Count0, BlkAcc0, Acc) -> + case A of + #b_literal{} -> + cg_atomic_args(As, L, Annos, FailBlk0, Count0, BlkAcc0, [A|Acc]); + #b_var{} -> + cg_atomic_args(As, L, Annos, FailBlk0, Count0, BlkAcc0, [A|Acc]); + none -> + throw(not_possible); + _ -> + {BlkAcc,Var,NextBlk,FailBlk,Count} = + cg_size_calc_1(L, A, Annos, FailBlk0, Count0, BlkAcc0), + cg_atomic_args(As, NextBlk, Annos, FailBlk, Count, BlkAcc, [Var|Acc]) + end; +cg_atomic_args([], NextBlk, _Annos, FailBlk, Count, BlkAcc, Acc) -> + {reverse(Acc),BlkAcc,NextBlk,FailBlk,Count}. + +new_var(Base, Count) -> + {#b_var{name={Base,Count}},Count+1}. + +new_blocks(N, Count) -> + new_blocks(N, Count, []). + +new_blocks(0, Count, Acc) -> + {Acc,Count}; +new_blocks(N, Count, Acc) -> + new_blocks(N - 1, Count + 1, [Count|Acc]). + +new_block(Count) -> + {Count,Count+1}. diff --git a/lib/compiler/src/beam_ssa_opt.erl b/lib/compiler/src/beam_ssa_opt.erl index 3cd25ff273..325c6da682 100644 --- a/lib/compiler/src/beam_ssa_opt.erl +++ b/lib/compiler/src/beam_ssa_opt.erl @@ -263,7 +263,11 @@ prologue_passes(Opts) -> passes_1(Ps, Opts). module_passes(Opts) -> - Ps0 = [{ssa_opt_type_start, + Ps0 = [{ssa_opt_bc_size, + fun({StMap, FuncDb}) -> + {beam_ssa_bc_size:opt(StMap), FuncDb} + end}, + {ssa_opt_type_start, fun({StMap, FuncDb}) -> beam_ssa_type:opt_start(StMap, FuncDb) end}], @@ -470,6 +474,7 @@ ssa_opt_merge_blocks({#opt_st{ssa=Blocks0}=St, FuncDb}) -> ssa_opt_split_blocks({#opt_st{ssa=Blocks0,cnt=Count0}=St, FuncDb}) -> P = fun(#b_set{op={bif,element}}) -> true; (#b_set{op=call}) -> true; + (#b_set{op=bs_init_writable}) -> true; (#b_set{op=make_fun}) -> true; (_) -> false end, diff --git a/lib/compiler/src/beam_ssa_type.erl b/lib/compiler/src/beam_ssa_type.erl index 8d7e6ad877..105ee12422 100644 --- a/lib/compiler/src/beam_ssa_type.erl +++ b/lib/compiler/src/beam_ssa_type.erl @@ -1323,15 +1323,27 @@ eval_type_test_bif(I, is_tuple, [Type]) -> eval_type_test_bif_1(I, Type, #t_tuple{}); eval_type_test_bif(I, Op, Types) -> case Types of - [#t_integer{},#t_integer{elements={0,0}}] - when Op =:= '+'; Op =:= '-'; Op =:= 'bor'; Op =:= 'bxor' -> + [#t_integer{},#t_integer{elements={0,0}}] when Op =:= 'bor'; Op =:= 'bxor' -> #b_set{args=[Result,_]} = I, Result; [#t_integer{},#t_integer{elements={0,0}}] when Op =:= '*'; Op =:= 'band' -> #b_literal{val=0}; - [#t_integer{},#t_integer{elements={1,1}}] when Op =:= '*'; Op =:= 'div' -> - #b_set{args=[Result,_]} = I, - Result; + [T,#t_integer{elements={0,0}}] when Op =:= '+'; Op =:= '-' -> + case beam_types:is_numerical_type(T) of + true -> + #b_set{args=[Result,_]} = I, + Result; + false -> + I + end; + [T,#t_integer{elements={1,1}}] when Op =:= '*'; Op =:= 'div' -> + case beam_types:is_numerical_type(T) of + true -> + #b_set{args=[Result,_]} = I, + Result; + false -> + I + end; [#t_integer{elements={LMin,LMax}},#t_integer{elements={RMin,RMax}}] -> case is_inequality_op(Op) of true -> diff --git a/lib/compiler/src/beam_types.erl b/lib/compiler/src/beam_types.erl index 5577fe79d8..48e720edd7 100644 --- a/lib/compiler/src/beam_types.erl +++ b/lib/compiler/src/beam_types.erl @@ -28,6 +28,7 @@ -export([meet/1, meet/2, join/1, join/2, subtract/2]). -export([is_boolean_type/1, + is_numerical_type/1, get_bs_matchable_unit/1, is_bs_matchable_type/1, get_singleton_value/1, @@ -464,6 +465,11 @@ is_boolean_type(#t_union{}=T) -> is_boolean_type(_) -> false. +-spec is_numerical_type(type()) -> boolean(). +is_numerical_type(#t_integer{}) -> true; +is_numerical_type(number) -> true; +is_numerical_type(_) -> false. + -spec set_tuple_element(Index, Type, Elements) -> Elements when Index :: pos_integer(), Type :: type(), diff --git a/lib/compiler/src/cerl_inline.erl b/lib/compiler/src/cerl_inline.erl index 8a2ea77b99..3f3d162302 100644 --- a/lib/compiler/src/cerl_inline.erl +++ b/lib/compiler/src/cerl_inline.erl @@ -903,9 +903,8 @@ i_fun(E, Ctxt, Ren, Env, S) -> %% side of each definition. i_letrec(E, Ctxt, Ren, Env, S) -> - %% We must turn off inlining if this `letrec' is specially - %% implemented. - NoInline = member(letrec_goto, get_ann(E)), + %% Test whether we must turn off inlining for this `letrec`. + NoInline = member(no_inline, get_ann(E)), %% Note that we pass an empty list for the auto-referenced %% (exported) functions here. diff --git a/lib/compiler/src/compile.erl b/lib/compiler/src/compile.erl index 525db89cd5..9818005d33 100644 --- a/lib/compiler/src/compile.erl +++ b/lib/compiler/src/compile.erl @@ -2008,6 +2008,7 @@ pre_load() -> beam_opcodes, beam_peep, beam_ssa, + beam_ssa_bc_size, beam_ssa_bool, beam_ssa_bsm, beam_ssa_codegen, diff --git a/lib/compiler/src/compiler.app.src b/lib/compiler/src/compiler.app.src index 5b18d91f6b..00db23ee20 100644 --- a/lib/compiler/src/compiler.app.src +++ b/lib/compiler/src/compiler.app.src @@ -36,6 +36,7 @@ beam_opcodes, beam_peep, beam_ssa, + beam_ssa_bc_size, beam_ssa_bool, beam_ssa_bsm, beam_ssa_codegen, diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl index 860976218a..a14ad988ae 100644 --- a/lib/compiler/src/v3_core.erl +++ b/lib/compiler/src/v3_core.erl @@ -82,7 +82,7 @@ -export([module/2,format_error/1]). -import(lists, [reverse/1,reverse/2,map/2,member/2,foldl/3,foldr/3,mapfoldl/3, - splitwith/2,keyfind/3,sort/1,foreach/2,droplast/1,last/1, + splitwith/2,keyfind/3,sort/1,droplast/1,last/1, duplicate/2]). -import(ordsets, [add_element/2,del_element/2,is_element/2, union/1,union/2,intersection/2,subtract/2]). @@ -1388,7 +1388,7 @@ lc_tq(Line, E, [#igen{anno=#a{anno=GA}=GAnno, F = #c_var{anno=LA,name={Name,1}}, Nc = #iapply{anno=GAnno,op=F,args=[Tail]}, {[FcVar,Var],St2} = new_vars(2, St1), - Fc = function_clause([FcVar], GA), + Fc = bad_generator([FcVar], FcVar, Arg), TailClause = #iclause{anno=LAnno,pats=[TailPat],guard=[],body=[Mc]}, Cs0 = case {AccPat,AccGuard} of {SkipPat,[]} -> @@ -1430,13 +1430,20 @@ lc_tq(Line, E0, [], Mc0, St0) -> bc_tq(Line, Exp, Qs0, St0) -> {BinVar,St1} = new_var(St0), - {Sz,SzPre,St2} = bc_initial_size(Exp, Qs0, St1), - {Qs,St3} = preprocess_quals(Line, Qs0, St2), - {E,BcPre,St} = bc_tq1(Line, Exp, Qs, BinVar, St3), - Pre = SzPre ++ - [#iset{var=BinVar, - arg=#iprimop{name=#c_literal{val=bs_init_writable}, - args=[Sz]}}] ++ BcPre, + {Qs1,St2} = preprocess_quals(Line, Qs0, St1), + {PrePre,Qs} = case Qs1 of + [#igen{arg={IgenPre,Arg}}=Igen|Igens] -> + {IgenPre,[Igen#igen{arg={[],Arg}}|Igens]}; + _ -> + {[],Qs1} + end, + {E,BcPre,St} = bc_tq1(Line, Exp, Qs, BinVar, St2), + InitialSize = #c_literal{val=256}, + Pre = PrePre ++ + [#iset{var=BinVar, + arg=#iprimop{anno=#a{anno=lineno_anno(Line, St)}, + name=#c_literal{val=bs_init_writable}, + args=[InitialSize]}}] ++ BcPre, {E,Pre,St}. bc_tq1(Line, E, [#igen{anno=GAnno, @@ -1451,7 +1458,7 @@ bc_tq1(Line, E, [#igen{anno=GAnno, {IgnoreVar,St4} = new_var(LA, St3), F = #c_var{anno=LA,name={Name,2}}, Nc = #iapply{anno=GAnno,op=F,args=[Tail,AccVar]}, - Fc = function_clause(FcVars, LA), + Fc = bad_generator(FcVars, hd(FcVars), Arg), TailClause = #iclause{anno=LAnno,pats=[TailPat,IgnoreVar],guard=[], body=[AccVar]}, Cs0 = case {AccPat,AccGuard} of @@ -1478,7 +1485,11 @@ bc_tq1(Line, E, [#igen{anno=GAnno, St5} end, Fun = #ifun{anno=LAnno,id=[],vars=Vars,clauses=Cs,fc=Fc}, - {#iletrec{anno=LAnno#a{anno=[list_comprehension|LA]},defs=[{{Name,2},Fun}], + + %% Inlining would disable the size calculation optimization for + %% bs_init_writable. + {#iletrec{anno=LAnno#a{anno=[list_comprehension,no_inline|LA]}, + defs=[{{Name,2},Fun}], body=Pre ++ [#iapply{anno=LAnno,op=F,args=[Arg,Mc]}]}, [],St}; bc_tq1(Line, E, [#ifilter{}=Filter|Qs], Mc, St) -> @@ -1707,249 +1718,6 @@ list_gen_pattern(P0, Line, St) -> nomatch -> {nomatch,add_warning(Line, nomatch, St)} end. -%%% -%%% Generate code to calculate the initial size for -%%% the result binary in a binary comprehension. -%%% - -bc_initial_size(E0, Q, St0) -> - try - E = bin_bin_element(E0), - {ElemSzExpr,ElemSzPre,EVs,St1} = bc_elem_size(E, St0), - {V,St2} = new_var(St1), - {GenSzExpr,GenSzPre,St3} = bc_gen_size(Q, EVs, St2), - case ElemSzExpr of - #c_literal{val=ElemSz} when ElemSz rem 8 =:= 0 -> - NumBytesExpr = #c_literal{val=ElemSz div 8}, - BytesExpr = [#iset{var=V, - arg=bc_mul(GenSzExpr, NumBytesExpr)}], - {V,ElemSzPre++GenSzPre++BytesExpr,St3}; - _ -> - {[BitsV,PlusSevenV],St} = new_vars(2, St3), - BitsExpr = #iset{var=BitsV,arg=bc_mul(GenSzExpr, ElemSzExpr)}, - PlusSevenExpr = #iset{var=PlusSevenV, - arg=bc_add(BitsV, #c_literal{val=7})}, - Expr = #iset{var=V, - arg=bc_bsr(PlusSevenV, #c_literal{val=3})}, - {V,ElemSzPre++GenSzPre++ - [BitsExpr,PlusSevenExpr,Expr],St} - end - catch - throw:impossible -> - {#c_literal{val=256},[],St0}; - throw:nomatch -> - {#c_literal{val=1},[],St0} - end. - -bc_elem_size({bin,_,El}, St0) -> - case bc_elem_size_1(El, ordsets:new(), 0, []) of - {Bits,[]} -> - {#c_literal{val=Bits},[],[],St0}; - {Bits,Vars0} -> - [{U,V0}|Pairs] = sort(Vars0), - F = bc_elem_size_combine(Pairs, U, [V0], []), - Vs = [V || {_,#c_var{name=V}} <- Vars0], - {E,Pre,St} = bc_mul_pairs(F, #c_literal{val=Bits}, [], St0), - {E,Pre,Vs,St} - end; -bc_elem_size(_, _) -> - throw(impossible). - -bc_elem_size_1([{bin_element,_,{string,_,String},{integer,_,N},_}=El|Es], - DefVars, Bits, SizeVars) -> - U = get_unit(El), - bc_elem_size_1(Es, DefVars, Bits+U*N*length(String), SizeVars); -bc_elem_size_1([{bin_element,_,Expr,{integer,_,N},_}=El|Es], - DefVars0, Bits, SizeVars) -> - U = get_unit(El), - DefVars = bc_elem_size_def_var(Expr, DefVars0), - bc_elem_size_1(Es, DefVars, Bits+U*N, SizeVars); -bc_elem_size_1([{bin_element,_,Expr,{var,_,Src},_}=El|Es], - DefVars0, Bits, SizeVars) -> - case ordsets:is_element(Src, DefVars0) of - false -> - U = get_unit(El), - DefVars = bc_elem_size_def_var(Expr, DefVars0), - bc_elem_size_1(Es, DefVars, Bits, [{U,#c_var{name=Src}}|SizeVars]); - true -> - throw(impossible) - end; -bc_elem_size_1([_|_], _, _, _) -> - throw(impossible); -bc_elem_size_1([], _DefVars, Bits, SizeVars) -> - {Bits,SizeVars}. - -bc_elem_size_def_var({var,_,Var}, DefVars) -> - ordsets:add_element(Var, DefVars); -bc_elem_size_def_var(_Expr, DefVars) -> - DefVars. - -bc_elem_size_combine([{U,V}|T], U, UVars, Acc) -> - bc_elem_size_combine(T, U, [V|UVars], Acc); -bc_elem_size_combine([{U,V}|T], OldU, UVars, Acc) -> - bc_elem_size_combine(T, U, [V], [{OldU,UVars}|Acc]); -bc_elem_size_combine([], U, Uvars, Acc) -> - [{U,Uvars}|Acc]. - -bc_mul_pairs([{U,L0}|T], E0, Pre, St0) -> - {AddExpr,AddPre,St1} = bc_add_list(L0, St0), - {[V1,V2],St} = new_vars(2, St1), - Set1 = #iset{var=V1,arg=bc_mul(AddExpr, #c_literal{val=U})}, - Set2 = #iset{var=V2,arg=bc_add(V1, E0)}, - bc_mul_pairs(T, V2, [Set2,Set1|reverse(AddPre, Pre)], St); -bc_mul_pairs([], E, Pre, St) -> - {E,reverse(Pre),St}. - -bc_add_list([V], St) -> - {V,[],St}; -bc_add_list([H|T], St) -> - bc_add_list_1(T, [], H, St). - -bc_add_list_1([H|T], Pre, E, St0) -> - {Var,St} = new_var(St0), - Set = #iset{var=Var,arg=bc_add(H, E)}, - bc_add_list_1(T, [Set|Pre], Var, St); -bc_add_list_1([], Pre, E, St) -> - {E,reverse(Pre),St}. - -bc_gen_size([_]=Q, EVs, St) -> - %% Single generator. - bc_gen_size_1(Q, EVs, #c_literal{val=1}, [], St); -bc_gen_size(_, _, _) -> - %% There are multiple generators (or there are filters). - %% To avoid introducing unbound variables in the size - %% calculation when one generator references a - %% variable bound by a previous generator, we will - %% not do any size calculation. This issue will be - %% handled in a cleaner way in OTP 24. - throw(impossible). - -bc_gen_size_1([{generate,L,El,Gen}|Qs], EVs, E0, Pre0, St0) -> - bc_verify_non_filtering(El, EVs), - case Gen of - {var,_,ListVar} -> - Lanno = lineno_anno(L, St0), - {LenVar,St1} = new_var(St0), - Set = #iset{var=LenVar, - arg=#icall{anno=#a{anno=Lanno}, - module=#c_literal{val=erlang}, - name=#c_literal{val=length}, - args=[#c_var{name=ListVar}]}}, - {E,Pre,St} = bc_gen_size_mul(E0, LenVar, [Set|Pre0], St1), - bc_gen_size_1(Qs, EVs, E, Pre, St); - _ -> - %% The only expressions we handle is literal lists. - Len = bc_list_length(Gen, 0), - {E,Pre,St} = bc_gen_size_mul(E0, #c_literal{val=Len}, Pre0, St0), - bc_gen_size_1(Qs, EVs, E, Pre, St) - end; -bc_gen_size_1([{b_generate,_,El0,Gen0}|Qs], EVs, E0, Pre0, St0) -> - El = bin_bin_element(El0), - Gen = bin_bin_element(Gen0), - bc_verify_non_filtering(El, EVs), - {MatchSzExpr,Pre1,_,St1} = bc_elem_size(El, St0), - Pre2 = reverse(Pre1, Pre0), - {ResVar,St2} = new_var(St1), - {BitSizeExpr,Pre3,St3} = bc_gen_bit_size(Gen, Pre2, St2), - Div = #iset{var=ResVar,arg=bc_div(BitSizeExpr, - MatchSzExpr)}, - Pre4 = [Div|Pre3], - {E,Pre,St} = bc_gen_size_mul(E0, ResVar, Pre4, St3), - bc_gen_size_1(Qs, EVs, E, Pre, St); -bc_gen_size_1([], _, E, Pre, St) -> - {E,reverse(Pre),St}; -bc_gen_size_1(_, _, _, _, _) -> - throw(impossible). - -bin_bin_element({bin,L,El}) -> - {bin,L,[bin_element(E) || E <- El]}; -bin_bin_element(Other) -> Other. - -bc_gen_bit_size({var,L,V}, Pre0, St0) -> - Lanno = lineno_anno(L, St0), - {SzVar,St} = new_var(St0), - Pre = [#iset{var=SzVar, - arg=#icall{anno=#a{anno=Lanno}, - module=#c_literal{val=erlang}, - name=#c_literal{val=bit_size}, - args=[#c_var{name=V}]}}|Pre0], - {SzVar,Pre,St}; -bc_gen_bit_size({bin,_,_}=Bin, Pre, St) -> - {#c_literal{val=bc_bin_size(Bin)},Pre,St}; -bc_gen_bit_size(_, _, _) -> - throw(impossible). - -bc_verify_non_filtering({bin,_,Els}, EVs) -> - foreach(fun({bin_element,_,{var,_,V},_,_}) -> - case member(V, EVs) of - true -> throw(impossible); - false -> ok - end; - (_) -> throw(impossible) - end, Els); -bc_verify_non_filtering({var,_,V}, EVs) -> - case member(V, EVs) of - true -> throw(impossible); - false -> ok - end; -bc_verify_non_filtering(_, _) -> - throw(impossible). - -bc_list_length({string,_,Str}, Len) -> - Len + length(Str); -bc_list_length({cons,_,_,T}, Len) -> - bc_list_length(T, Len+1); -bc_list_length({nil,_}, Len) -> - Len; -bc_list_length(_, _) -> - throw(impossible). - -bc_bin_size({bin,_,Els}) -> - bc_bin_size_1(Els, 0). - -bc_bin_size_1([{bin_element,_,{string,_,String},{integer,_,Sz},_}=El|Els], N) -> - U = get_unit(El), - bc_bin_size_1(Els, N+U*Sz*length(String)); -bc_bin_size_1([{bin_element,_,_,{integer,_,Sz},_}=El|Els], N) -> - U = get_unit(El), - bc_bin_size_1(Els, N+U*Sz); -bc_bin_size_1([], N) -> N; -bc_bin_size_1(_, _) -> throw(impossible). - -bc_gen_size_mul(#c_literal{val=1}, E, Pre, St) -> - {E,Pre,St}; -bc_gen_size_mul(E1, E2, Pre, St0) -> - {V,St} = new_var(St0), - {V,[#iset{var=V,arg=bc_mul(E1, E2)}|Pre],St}. - -bc_mul(E1, #c_literal{val=1}) -> - E1; -bc_mul(E1, E2) -> - #icall{module=#c_literal{val=erlang}, - name=#c_literal{val='*'}, - args=[E1,E2]}. - -bc_div(E1, E2) -> - #icall{module=#c_literal{val=erlang}, - name=#c_literal{val='div'}, - args=[E1,E2]}. - -bc_add(E1, #c_literal{val=0}) -> - E1; -bc_add(E1, E2) -> - #icall{module=#c_literal{val=erlang}, - name=#c_literal{val='+'}, - args=[E1,E2]}. - -bc_bsr(E1, E2) -> - #icall{module=#c_literal{val=erlang}, - name=#c_literal{val='bsr'}, - args=[E1,E2]}. - -get_unit({bin_element,_,_,_,Flags}) -> - {unit,U} = keyfind(unit, 1, Flags), - U. - %% is_guard_test(Expression) -> true | false. %% Test if a general expression is a guard test. %% @@ -2020,7 +1797,7 @@ force_safe(Ce, St0) -> case is_safe(Ce) of true -> {Ce,[],St0}; false -> - {V,St1} = new_var(St0), + {V,St1} = new_var(get_lineno_anno(Ce), St0), {V,[#iset{var=V,arg=Ce}],St1} end. @@ -2284,6 +2061,11 @@ new_vars_1(N, Anno, St0, Vs) when N > 0 -> new_vars_1(N-1, Anno, St1, [V|Vs]); new_vars_1(0, _, St, Vs) -> {Vs,St}. +bad_generator(Ps, Generator, Arg) -> + Anno = get_anno(Arg), + Tuple = ann_c_tuple(Anno, [#c_literal{val=bad_generator},Generator]), + fail_clause(Ps, Anno, Tuple). + function_clause(Ps, LineAnno) -> fail_clause(Ps, LineAnno, ann_c_tuple(LineAnno, [#c_literal{val=function_clause}|Ps])). @@ -3157,7 +2939,7 @@ lexpr(#c_receive{clauses=[],timeout=Timeout0,action=Action}, St0) -> Fun = #c_fun{vars=[],body=TimeoutLet}, - Letrec = #c_letrec{anno=[letrec_goto], + Letrec = #c_letrec{anno=[letrec_goto,no_inline], defs=[{LoopFun,Fun}], body=ApplyLoop}, @@ -3223,7 +3005,7 @@ lexpr(#c_receive{anno=RecvAnno,clauses=Cs0,timeout=Timeout0,action=Action}, St0) body=PeekCase}, Fun = #c_fun{vars=[],body=PeekLet}, - Letrec = #c_letrec{anno=[letrec_goto], + Letrec = #c_letrec{anno=[letrec_goto,no_inline], defs=[{LoopFun,Fun}], body=ApplyLoop}, @@ -3294,7 +3076,7 @@ split_letify([], [], Body, [_|_]=VsAcc, [_|_]=ArgAcc) -> split_case_letrec(#c_fun{anno=FunAnno0}=Fun0, Body, #core{gcount=C}=St0) -> FunAnno = [compiler_generated|FunAnno0], Fun = Fun0#c_fun{anno=FunAnno}, - Anno = [letrec_goto], + Anno = [letrec_goto,no_inline], DefFunName = goto_func(C), Letrec = #c_letrec{anno=Anno,defs=[{#c_var{name=DefFunName},Fun}],body=Body}, St = St0#core{gcount=C+1}, diff --git a/lib/compiler/test/beam_except_SUITE.erl b/lib/compiler/test/beam_except_SUITE.erl index 1a9406b5ea..2540a0a911 100644 --- a/lib/compiler/test/beam_except_SUITE.erl +++ b/lib/compiler/test/beam_except_SUITE.erl @@ -52,7 +52,7 @@ end_per_group(_GroupName, Config) -> multiple_allocs(_Config) -> {'EXIT',{{badmatch,#{true:=[p]}},_}} = (catch could(pda, 0.0, {false,true}, {p})), - {'EXIT',{function_clause,_}} = (catch place(lee)), + {'EXIT',{{bad_generator,0},_}} = (catch place(lee)), {'EXIT',{{badmatch,wanted},_}} = (catch conditions()), ok. diff --git a/lib/compiler/test/bs_bincomp_SUITE.erl b/lib/compiler/test/bs_bincomp_SUITE.erl index ddd804f133..b9d3d3eb4a 100644 --- a/lib/compiler/test/bs_bincomp_SUITE.erl +++ b/lib/compiler/test/bs_bincomp_SUITE.erl @@ -27,7 +27,7 @@ byte_aligned/1,bit_aligned/1,extended_byte_aligned/1, extended_bit_aligned/1,mixed/1,filters/1,trim_coverage/1, nomatch/1,sizes/1,general_expressions/1,matched_out_size/1, - no_generator/1]). + no_generator/1,zero_pattern/1]). -include_lib("common_test/include/ct.hrl"). @@ -37,7 +37,7 @@ all() -> [byte_aligned, bit_aligned, extended_byte_aligned, extended_bit_aligned, mixed, filters, trim_coverage, nomatch, sizes, general_expressions, matched_out_size, - no_generator]. + no_generator, zero_pattern]. groups() -> []. @@ -69,8 +69,7 @@ bit_aligned(Config) when is_list(Config) -> cs_init(), <<$a:7,$b:7,$c:7,$d:7,$e:7,$f:7,$g:7>> = cs(<< <<(X+32):7>> || <<X>> <= <<"ABCDEFG">> >>), - <<"ABCDEFG">> = - cs(<< <<(X-32)>> || <<X:7>> <= <<$a:7,$b:7,$c:7,$d:7,$e:7,$f:7,$g:7>> >>), + <<"ABCDEFG">> = cs(<< <<(X-32)>> || <<X:7>> <= id(<<$a:7,$b:7,$c:7,$d:7,$e:7,$f:7,$g:7>>) >>), <<1:31/little,2:31/little,3:31/little,4:31/little>> = cs(<< <<X:31/little>> || <<X:31>> <= <<1:31,2:31,3:31,4:31>> >>), <<1:31/little,2:31/little,3:31/little,4:31/little>> = @@ -131,11 +130,47 @@ mixed(Config) when is_list(Config) -> <<1>> = cs_default(<< <<X>> || L <- [[1]], X <- L >>), + %% The compiler would crash in v3_kernel. + <<42:32,75:32,253:32,(42 bsl 8 bor 75):32>> = + cs_default(mixed_size(id([8,16]), <<42,75,253>>)), + + silly_lc_bc(5), + + gen_data(0), + gen_data(256), + gen_data(512), + cs_end(). mixed_nested(L) -> << << << << E:16 >> || E <- L >> || true >>/binary, 99:(id(8))>>. +mixed_size(List, Bin) -> + << <<X:32>> || Size <- List, <<X:Size>> <= Bin >>. + +silly_lc_bc(N) when N > 0 -> + Bin = iolist_to_binary(silly_lc(N)), + Bin = cs(silly_bc(N)), + Size = byte_size(Bin), + Size = 5 bsl N, + silly_lc_bc(N - 1); +silly_lc_bc(_) -> ok. + +silly_bc(0) -> + <<0, 1, 2, 3, 4>>; +silly_bc(N) -> + << <<X, X>> || <<X>> <= silly_bc(N - 1) >>. + +silly_lc(0) -> + [0, 1, 2, 3, 4]; +silly_lc(N) -> + [[X, X] || X <- silly_lc(N - 1)]. + +gen_data(Size) -> + Data = cs(<< <<C>> || C <- lists:seq(0, Size-1) >>), + Data = << <<C>> || _ <- lists:seq(1, Size div 256), + C <- lists:seq(0, 255) >>. + filters(Config) when is_list(Config) -> cs_init(), <<"BDF">> = @@ -162,6 +198,7 @@ filters(Config) when is_list(Config) -> [] -> false; [_|_] -> true end >>), + <<77,42>> = cs_default(<< <<B>> || <<B>> <- [<<77>>,<<1,2>>,<<42>>] >>), %% Filtering by a non-matching pattern. <<"abd">> = cs_default(<< <<X:8>> || @@ -217,8 +254,16 @@ nomatch(Config) when is_list(Config) -> NaN = <<(-1):32>>, <<>> = << <<"a">> || <<_:32/float>> <= NaN >>, + <<1:32,2:32,3:32>> = nomatch_1(<<1,2,3>>, 8), + <<>> = nomatch_1(<<1,2,3>>, bad), + + <<>> = << <<>> || <<_:8>> <= <<>> >>, + ok. +nomatch_1(Bin, Size) -> + << <<X:32>> || <<X:Size>> <= Bin >>. + sizes(Config) when is_list(Config) -> cs_init(), Fun0 = fun(List) -> @@ -311,7 +356,7 @@ sizes(Config) when is_list(Config) -> <<17:9,19:9>> = Fun12(<<17:6,19:6>>, 9, 6), Fun13 = fun(Sz) -> - cs_default(<< <<C:8>> || <<C:4>> <= <<1:4,2:4,3:4,0:Sz>> >>) + cs(<< <<C:8>> || <<C:4>> <= <<1:4,2:4,3:4,0:Sz>> >>) end, <<1,2,3>> = Fun13(0), <<1,2,3,0>> = Fun13(4), @@ -323,6 +368,12 @@ sizes(Config) when is_list(Config) -> <<0:3>> = cs_default(<< <<0:S>> || S <- [0,1,2] >>), <<0:3>> = cs_default(<< <<0:S>> || <<S>> <= <<0,1,2>> >>), + Fun14 = fun(L, B) -> + cs_default(<< <<X:32>> || Size <- L, <<X:Size>> <= B >>) + end, + <<$a:32,$b:32,$c:32,($a bsl 8 bor $b):32>> = Fun14([8,16], <<"abc">>), + <<$a:32,$b:32,$c:32>> = Fun14([8,bad], <<"abc">>), + {'EXIT',_} = (catch << <<C:4>> || <<C:8>> <= {1,2,3} >>), cs_end(), @@ -334,8 +385,8 @@ sizes(Config) when is_list(Config) -> general_expressions(_) -> cs_init(), - <<1,2,3>> = cs_default(<< begin <<1,2,3>> end || _ <- [1] >>), - <<"abc">> = cs_default(<< begin <<"abc">> end || _ <- [1] >>), + <<1,2,3>> = cs(<< begin <<1,2,3>> end || _ <- [1] >>), + <<"abc">> = cs(<< begin <<"abc">> end || _ <- [1] >>), <<1,2,3>> = cs_default(<< begin I = <<(I0+1)>>, id(I) @@ -411,6 +462,27 @@ no_generator(_Config) -> ok. +zero_pattern(Config) -> + case is_atom(Config) of + true -> + %% Patterns that match zero bits loops forever, so we must + %% be careful not to execute them. + _ = << <<>> || <<>> <= <<>> >>, + _ = << <<42>> || <<>> <= <<42>> >>, + _ = << + <<>> || + <<>> <= << >>, + <<3:back>> <= << >> + >>, + _ = << + <<>> || + <<>> <= <<>>, + <<>> <- << <<>> || area >> + >>; + false -> + ok + end. + cs_init() -> erts_debug:set_internal_state(available_internal_state, true), ok. @@ -421,9 +493,18 @@ cs_end() -> %% Verify that the allocated size is exact (rounded up to the nearest byte). cs(Bin) -> - ByteSize = byte_size(Bin), - {refc_binary,ByteSize,{binary,ByteSize},_} = - erts_debug:get_internal_state({binary_info,Bin}), + case ?MODULE of + bs_bincomp_no_opt_SUITE -> + ok; + bs_bincomp_no_ssa_opt_SUITE -> + ok; + bs_bincomp_post_opt_SUITE -> + ok; + _ -> + ByteSize = byte_size(Bin), + {refc_binary,ByteSize,{binary,ByteSize},_} = + erts_debug:get_internal_state({binary_info,Bin}) + end, Bin. %% Verify that the allocated size of the binary is the default size. diff --git a/lib/compiler/test/lc_SUITE.erl b/lib/compiler/test/lc_SUITE.erl index c80b7cc59e..47579145ef 100644 --- a/lib/compiler/test/lc_SUITE.erl +++ b/lib/compiler/test/lc_SUITE.erl @@ -106,32 +106,30 @@ basic(Config) when is_list(Config) -> {'EXIT',_} = (catch [X || X <- L1, list_to_atom(X) == dum]), [] = [X || X <- L1, X+1 < 2], {'EXIT',_} = (catch [X || X <- L1, odd(X)]), - fc([x], catch [E || E <- id(x)]), + {'EXIT',{{bad_generator,x},_}} = (catch [E || E <- id(x)]), %% Make sure that line numbers point out the generator. case ?MODULE of lc_inline_SUITE -> ok; _ -> - {'EXIT',{function_clause, + {'EXIT',{{bad_generator,a}, [{?MODULE,_,_, [{file,"bad_lc.erl"},{line,4}]}|_]}} = - (catch bad_generator(a)), - {'EXIT',{function_clause, + (catch id(bad_generator(a))), + + {'EXIT',{{bad_generator,a}, [{?MODULE,_,_, - [{file,"bad_lc.erl"},{line,4}]}|_]}} = - (catch bad_generator([a|b])), - {'EXIT',{badarg, - [{erlang,length,_,_}, - {?MODULE,bad_generator_bc,1, [{file,"bad_lc.erl"},{line,7}]}|_]}} = - (catch bad_generator_bc(a)), - {'EXIT',{badarg, - [{erlang,length,_,_}, - {?MODULE,bad_generator_bc,1, - [{file,"bad_lc.erl"},{line,7}]}|_]}} = - (catch bad_generator_bc([a|b])) + (catch id(bad_generator_bc(a))), + + %% List comprehensions with improper lists. + {'EXIT',{{bad_generator,d}, + [{?MODULE,_,_, + [{file,"bad_lc.erl"},{line,4}]}|_]}} = + (catch bad_generator(id([a,b,c|d]))) end, + ok. tuple_list() -> @@ -267,14 +265,6 @@ do_effect(Lc, L) -> id(I) -> I. -fc(Args, {'EXIT',{function_clause,[{?MODULE,_,Args,_}|_]}}) -> ok; -fc(Args, {'EXIT',{function_clause,[{?MODULE,_,Arity,_}|_]}}) - when length(Args) =:= Arity -> - true = test_server:is_native(?MODULE); -fc(Args, {'EXIT',{{case_clause,ActualArgs},_}}) - when ?MODULE =:= lc_inline_SUITE -> - Args = tuple_to_list(ActualArgs). - -file("bad_lc.erl", 1). bad_generator(List) -> %Line 2 [I || %Line 3 diff --git a/lib/compiler/test/misc_SUITE.erl b/lib/compiler/test/misc_SUITE.erl index bc07099915..4e577311cc 100644 --- a/lib/compiler/test/misc_SUITE.erl +++ b/lib/compiler/test/misc_SUITE.erl @@ -210,6 +210,9 @@ silly_coverage(Config) when is_list(Config) -> BadSSABlocks,0}]}, expect_error(fun() -> beam_ssa_opt:module(BadSSAOpt, []) end), + %% beam_ssa_bc_size + cover_beam_ssa_bc_size(1), + %% beam_ssa_lint, beam_ssa_pp {error,[{_,Errors}]} = beam_ssa_lint:module(bad_ssa_lint_input(), []), _ = [io:put_chars(Mod:format_error(Reason)) || @@ -282,6 +285,15 @@ silly_coverage(Config) when is_list(Config) -> ok. +cover_beam_ssa_bc_size(20) -> + ok; +cover_beam_ssa_bc_size(N) -> + BcSizeKey = {b_local,{b_literal,name},1}, + %% Try different sizes for the opt_st record. + OptSt = erlang:make_tuple(N, whatever, [{1,opt_st}]), + expect_error(fun() -> beam_ssa_bc_size:opt(#{BcSizeKey => OptSt}) end), + cover_beam_ssa_bc_size(N + 1). + bad_ssa_lint_input() -> {b_module,#{},t, [{a,1},{b,1},{c,1},{module_info,0},{module_info,1}], -- 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
