File 2743-v3_core-Raise-clearer-exceptions-when-gene... of Package erlang

Overview Repositories Revisions Requests Users Attributes Meta

File 2743-v3_core-Raise-clearer-exceptions-when-generators-are.patch of Package erlang (Revision fcc54f6733a70ae4c018943d955238fa)

Currently displaying revision fcc54f6733a70ae4c018943d955238fa , Show latest

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

Places

File 2743-v3_core-Raise-clearer-exceptions-when-generators-are.patch of Package erlang (Revision fcc54f6733a70ae4c018943d955238fa)

Places