File 2172-compiler-Suppress-stack-traces-for-throw-1-when-they.patch of Package erlang
From 1067ef391c492683e91f7d4d7a4a96fbd2a26b05 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?John=20H=C3=B6gberg?= <john@erlang.org>
Date: Mon, 28 Sep 2020 14:33:31 +0200
Subject: [PATCH 2/2] compiler: Suppress stack traces for throw/1 when they're
not used
---
lib/compiler/src/Makefile | 2 +
lib/compiler/src/beam_ssa.erl | 2 +-
lib/compiler/src/beam_ssa_throw.erl | 495 +++++++++++++++++++++++++++
lib/compiler/src/beam_ssa_type.erl | 30 +-
lib/compiler/src/compile.erl | 5 +
lib/compiler/src/compiler.app.src | 1 +
lib/compiler/test/trycatch_SUITE.erl | 73 ++++
7 files changed, 596 insertions(+), 12 deletions(-)
create mode 100644 lib/compiler/src/beam_ssa_throw.erl
diff --git a/lib/compiler/src/Makefile b/lib/compiler/src/Makefile
index b1531ac985..d4eacfa154 100644
--- a/lib/compiler/src/Makefile
+++ b/lib/compiler/src/Makefile
@@ -71,6 +71,7 @@ MODULES = \
beam_ssa_pre_codegen \
beam_ssa_recv \
beam_ssa_share \
+ beam_ssa_throw \
beam_ssa_type \
beam_kernel_to_ssa \
beam_trim \
@@ -210,6 +211,7 @@ $(EBIN)/beam_ssa_pp.beam: beam_ssa.hrl
$(EBIN)/beam_ssa_pre_codegen.beam: beam_ssa.hrl
$(EBIN)/beam_ssa_recv.beam: beam_ssa.hrl
$(EBIN)/beam_ssa_share.beam: beam_ssa.hrl
+$(EBIN)/beam_ssa_throw.beam: beam_ssa.hrl
$(EBIN)/beam_ssa_type.beam: beam_ssa.hrl beam_types.hrl
$(EBIN)/beam_types.beam: beam_types.hrl
$(EBIN)/beam_validator.beam: beam_types.hrl
diff --git a/lib/compiler/src/beam_ssa.erl b/lib/compiler/src/beam_ssa.erl
index aa971b5f57..be251d0c78 100644
--- a/lib/compiler/src/beam_ssa.erl
+++ b/lib/compiler/src/beam_ssa.erl
@@ -50,7 +50,7 @@
var_name/0,var_base/0,literal_value/0,
op/0,anno/0,block_map/0,dominator_map/0,
rename_map/0,rename_proplist/0,usage_map/0,
- definition_map/0]).
+ definition_map/0,predecessor_map/0]).
-include("beam_ssa.hrl").
diff --git a/lib/compiler/src/beam_ssa_throw.erl b/lib/compiler/src/beam_ssa_throw.erl
new file mode 100644
index 0000000000..3e0ce49056
--- /dev/null
+++ b/lib/compiler/src/beam_ssa_throw.erl
@@ -0,0 +1,495 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2020-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%
+%%
+
+%%%
+%%% This pass skips stack trace generation on erlang:throw/1 when they're
+%%% guaranteed not to be inspected.
+%%%
+%%% It does so by finding all exception handlers in the module, determining
+%%% which functions they cover, and then simulating the result of every throw/1
+%%% in the module; if a particular throw/1 never reaches an instruction that
+%%% creates a stack trace, then it's safe to rewrite it.
+%%%
+
+-module(beam_ssa_throw).
+
+-export([module/2]).
+
+-import(lists, [foldl/3]).
+
+-include("beam_ssa.hrl").
+-include("beam_types.hrl").
+
+-type exception_var() :: none | #b_var{}.
+-type exception_vars() :: {Class :: exception_var(),
+ Reason :: exception_var(),
+ Stacktrace :: exception_var()}.
+-type tentative() :: {tentative,
+ Start :: beam_ssa:label(),
+ Vars :: exception_vars(),
+ Blocks :: beam_ssa:block_map()}.
+
+-type handler() :: tentative() | unsuitable | suitable.
+-type handler_id() :: {#b_local{}, beam_ssa:label()}.
+
+-type suitability() :: {tentative, beam_ssa:label()} |
+ unsuitable |
+ suitable.
+
+%% Per-module scan state
+-record(gst, {tlh_roots :: gb_trees:tree(#b_local{}, gb_sets:set(handler())),
+ tlh_edges=#{} :: #{ #b_local{} => gb_sets:set(#b_local{}) },
+ throws=cerl_sets:new() :: cerl_sets:set(#b_local{})}).
+
+%% Per-function scan state
+-record(lst, {suitability=#{} :: #{ #b_var{} => suitability() },
+ handlers=#{} :: #{ handler_id() => handler() },
+ blocks :: beam_ssa:block_map(),
+ predecessors :: beam_ssa:predecessor_map()}).
+
+-spec module(beam_ssa:b_module(), [compile:option()]) ->
+ {'ok',beam_ssa:b_module()}.
+
+module(#b_module{body=Fs0}=Module, _Opts) ->
+ case scan(Module) of
+ {Throws, TLHs} ->
+ Fs = opt(Fs0, Throws, TLHs),
+ {ok, Module#b_module{body=Fs}};
+ no_throws ->
+ {ok, Module}
+ end.
+
+%% Builds a map with the top-level exception handlers (TLHs) for each function,
+%% as well as the set of functions that call throw/1.
+scan(#b_module{body=Fs0}=Module) ->
+ scan_1(Fs0, init_gst(Module)).
+
+init_gst(#b_module{exports=Exports}) ->
+ %% We can't optimize any throw that leaves the module, so we'll add an
+ %% unsuitable top-level handler to all exported functions.
+ Unsuitable = gb_sets:singleton(unsuitable),
+ Roots = foldl(fun({Name, Arity}, Acc) ->
+ Id = #b_local{name=#b_literal{val=Name},arity=Arity},
+ gb_trees:insert(Id, Unsuitable, Acc)
+ end, gb_trees:empty(), Exports),
+ #gst{tlh_roots=Roots}.
+
+scan_1([#b_function{bs=Blocks}=F | Fs], Gst0) ->
+ Id = get_func_id(F),
+
+ Preds = beam_ssa:predecessors(Blocks),
+ Linear = beam_ssa:linearize(Blocks),
+
+ Lst = #lst{blocks=Blocks,predecessors=Preds},
+ {_, Gst} = scan_bs(Linear, Id, Lst, Gst0),
+
+ scan_1(Fs, Gst);
+scan_1([], Gst) ->
+ #gst{tlh_roots=Roots,
+ tlh_edges=Edges,
+ throws=Throws} = Gst,
+
+ case cerl_sets:size(Throws) of
+ 0 ->
+ no_throws;
+ _ ->
+ TLHs = propagate_tlhs(gb_trees:to_list(Roots), Edges, #{}),
+ {Throws, TLHs}
+ end.
+
+%% Propagates all top-level handlers to the functions they cover. See
+%% inherit_tlh/3 and add_tlh/3.
+propagate_tlhs([{Id, HandlersA} | Roots], Edges, Acc0) ->
+ HandlersB = maps:get(Id, Acc0, gb_sets:empty()),
+ case gb_sets:is_subset(HandlersA, HandlersB) of
+ true ->
+ propagate_tlhs(Roots, Edges, Acc0);
+ false ->
+ Merged = gb_sets:union(HandlersA, HandlersB),
+ Callees = pt_callees(Id, Merged, Edges),
+
+ Acc = propagate_tlhs(Callees, Edges, Acc0#{ Id => Merged }),
+ propagate_tlhs(Roots, Edges, Acc)
+ end;
+propagate_tlhs([], _Edges, Acc) ->
+ Acc.
+
+pt_callees(Id, Merged, Edges) ->
+ case Edges of
+ #{ Id := Callees } ->
+ gb_sets:fold(fun(Callee, Acc) ->
+ [{Callee, Merged} | Acc]
+ end, [], Callees);
+ #{} ->
+ []
+ end.
+
+%% We scan the blocks in post-order so we can finish analyzing handlers before
+%% reaching their affected calls. This lets us avoid unnecessary indirection
+%% when adding or inspecting top-level handlers.
+scan_bs([{?EXCEPTION_BLOCK, _} | Bs], Id, Lst, Gst) ->
+ scan_bs(Bs, Id, Lst, Gst);
+scan_bs([{Lbl, #b_blk{last=Last,is=Is}} | Bs], Id, Lst0, Gst0) ->
+ {Lst, Gst} = scan_bs(Bs, Id, Lst0, Gst0),
+ si_is(Is, Id, Lbl, Last, Lst, Gst);
+scan_bs([], _Id, Lst, Gst) ->
+ {Lst, Gst}.
+
+si_is([#b_set{op=landingpad,args=[_Kind, _Tag]} | Is],
+ Id, Lbl, Last, Lst, Gst) ->
+ %% Class:Reason:Stacktrace
+ Vars = {none, none, none},
+ si_handler_start(Is, Id, Lbl, Last, Vars, Lst, Gst);
+si_is([#b_set{op=resume,args=[Stacktrace, _Reason]} | Is],
+ Id, Lbl, Last, Lst, Gst) ->
+ si_handler_end(Is, Id, Lbl, Last, Stacktrace, Lst, Gst);
+si_is([#b_set{op=raw_raise,args=[_,_,Stacktrace]} | Is],
+ Id, Lbl, Last, Lst, Gst) ->
+ si_handler_end(Is, Id, Lbl, Last, Stacktrace, Lst, Gst);
+si_is([#b_set{op=build_stacktrace,args=[Stacktrace]} | Is],
+ Id, Lbl, Last, Lst, Gst) ->
+ si_handler_end(Is, Id, Lbl, Last, Stacktrace, Lst, Gst);
+si_is([#b_set{op=call,
+ dst=Dst,
+ args=[#b_remote{mod=#b_literal{val=erlang},
+ name=#b_literal{val=throw},
+ arity=1}, _Term]}],
+ Id, _Lbl, #b_ret{arg=Dst}, Lst, Gst) ->
+ %% Tail throw, handled by caller. We'll need to visit this function again.
+ #gst{throws=Throws0} = Gst,
+ Throws = cerl_sets:add_element(Id, Throws0),
+ {Lst, Gst#gst{throws=Throws}};
+si_is([#b_set{op=call,dst=Dst,args=[#b_local{}=Callee | _]}],
+ Id, _Lbl, #b_ret{arg=Dst}, Lst, Gst) ->
+ %% Tail call, inherit our caller's handler.
+ {Lst, inherit_tlh(Id, Callee, Gst)};
+si_is([#b_set{op=call,dst=Dst,args=[#b_local{}=Callee | _]},
+ #b_set{op={succeeded,body},args=[Dst]}],
+ Id, _Lbl, #b_br{fail=?EXCEPTION_BLOCK}, Lst, Gst) ->
+ %% No local handler, inherit our caller's top-level handlers.
+ {Lst, inherit_tlh(Id, Callee, Gst)};
+si_is([#b_set{op=call,dst=Dst,args=[#b_local{}=Callee | _]},
+ #b_set{op={succeeded,body},args=[Dst]}],
+ Id, _Lbl, #b_br{fail=Fail}, Lst, Gst) ->
+ %% Local handler, register it as a top-level handler with our callee.
+ HandlerId = {Id, Fail},
+ {Lst, add_tlh(HandlerId, Callee, Lst, Gst)};
+si_is([#b_set{} | Is], Id, Lbl, Last, Lst, Gst) ->
+ si_is(Is, Id, Lbl, Last, Lst, Gst);
+si_is([], _Id, _Lbl, _Last, Lst, Gst) ->
+ {Lst, Gst}.
+
+%% Marks the end of a handler. Note that we encounter this _before_ the start
+%% since we iterate the blocks in post-order.
+si_handler_end(Is, Id, EndLbl, Last, Stacktrace, Lst0, Gst) ->
+ #lst{suitability=Suitability0} = Lst0,
+
+ Marker = case Suitability0 of
+ #{ Stacktrace := {tentative, _} } ->
+ %% Multiple uses make partitioning more difficult, so
+ %% we'll disqualify this handler to save us the hassle.
+ unsuitable;
+ #{} ->
+ %% This handler may or may not be suitable depending on
+ %% what's thrown, so we keep it for later analysis.
+ {tentative, EndLbl}
+ end,
+
+ Suitability = Suitability0#{ Stacktrace => Marker },
+
+ Lst = Lst0#lst{suitability=Suitability},
+ si_is(Is, Id, EndLbl, Last, Lst, Gst).
+
+si_handler_start([#b_set{op=extract,
+ dst=Dst,
+ args=[_, #b_literal{val=Idx}]} | Is],
+ Id, StartLbl, Last, Vars0, Lst, Gst) ->
+ none = element(1 + Idx, Vars0), %Assertion.
+ Vars = setelement(1 + Idx, Vars0, Dst),
+ si_handler_start(Is, Id, StartLbl, Last, Vars, Lst, Gst);
+si_handler_start(Is, Id, StartLbl, Last, Vars, Lst0, Gst) ->
+ HandlerId = {Id, StartLbl},
+
+ #lst{blocks=Blocks,
+ predecessors=Preds,
+ suitability=Suitability,
+ handlers=Handlers0} = Lst0,
+
+ {_, _, Stacktrace} = Vars,
+
+ Handlers = case Suitability of
+ #{ Stacktrace := {tentative, EndLbl} } ->
+ %% This handler's suitability depends on what we throw,
+ %% so we'll extract the blocks between handler start and
+ %% the first use of the stack trace for later analysis.
+ Path = beam_ssa:between(StartLbl, EndLbl, Preds, Blocks),
+ Partition = maps:with(Path, Blocks),
+
+ Handler = {tentative, StartLbl, Vars, Partition},
+ Handlers0#{ HandlerId => Handler };
+ #{} when Stacktrace =/= none ->
+ %% Stack trace is used in an unsupported manner.
+ Handlers0#{ HandlerId => unsuitable };
+ #{} when Stacktrace =:= none ->
+ %% Stack trace is never used, so it's always safe to
+ %% skip trace generation.
+ Handlers0#{ HandlerId => suitable }
+ end,
+
+ Lst = Lst0#lst{handlers=Handlers},
+
+ si_is(Is, Id, StartLbl, Last, Lst, Gst).
+
+%% Makes the callee inherit its callers top-level handlers
+inherit_tlh(Caller, Callee, #gst{tlh_edges=Edges0}=Gst) ->
+ Callees = case Edges0 of
+ #{ Caller := Callees0 } ->
+ gb_sets:add_element(Callee, Callees0);
+ #{} ->
+ gb_sets:singleton(Callee)
+ end,
+ Edges = Edges0#{ Caller => Callees },
+ Gst#gst{tlh_edges=Edges}.
+
+%% Registers the given handler as a top-level handler for Callee
+add_tlh(Id, Callee, Lst, Gst) ->
+ #lst{handlers=Handlers} = Lst,
+ #gst{tlh_roots=Roots0} = Gst,
+
+ #{ Id := Handler } = Handlers,
+
+ TLHs0 = case gb_trees:lookup(Callee, Roots0) of
+ none -> gb_sets:singleton(Handler);
+ {value, V} -> V
+ end,
+
+ TLHs = case gb_sets:is_element(unsuitable, TLHs0) of
+ true ->
+ %% One bad apple spoils the bunch.
+ TLHs0;
+ false ->
+ gb_sets:add_element(Handler, TLHs0)
+ end,
+
+ Roots = gb_trees:enter(Callee, TLHs, Roots0),
+ Gst#gst{tlh_roots=Roots}.
+
+%% Goes through all functions that call throw/1, checking whether the stack
+%% trace is unused in all of its top-level exception handlers (TLHs), and
+%% rewriting such calls to `raise(throw, Term, [])`.
+opt([#b_function{bs=Blocks0}=F | Fs], Throws, TLHs) ->
+ Id = get_func_id(F),
+
+ Blocks = case {cerl_sets:is_element(Id, Throws), TLHs} of
+ {true, #{ Id := Handlers } } ->
+ opt_function(Handlers, Blocks0);
+ {_, _} ->
+ %% We're either unreachable or never throw.
+ Blocks0
+ end,
+
+ [F#b_function{bs=Blocks} | opt(Fs, Throws, TLHs)];
+opt([], _Throws, _TLHs) ->
+ [].
+
+get_func_id(#b_function{anno=Anno}) ->
+ {_,Name,Arity} = maps:get(func_info, Anno),
+ #b_local{name=#b_literal{val=Name},arity=Arity}.
+
+opt_function(Handlers, Blocks) ->
+ case gb_sets:is_member(unsuitable, Handlers) of
+ true ->
+ Blocks;
+ false ->
+ Linear0 = beam_ssa:linearize(Blocks),
+ Linear = opt_bs(Linear0, gb_sets:to_list(Handlers)),
+ maps:from_list(Linear)
+ end.
+
+opt_bs([{Lbl, #b_blk{last=Last,is=Is0}=Blk} | Bs], Hs) ->
+ Is = opt_is(Is0, Last, Hs),
+ [{Lbl, Blk#b_blk{is=Is}} | opt_bs(Bs, Hs)];
+opt_bs([], _Hs) ->
+ [].
+
+opt_is([#b_set{op=call,
+ dst=Dst,
+ args=[#b_remote{mod=#b_literal{val=erlang},
+ name=#b_literal{val=throw},
+ arity=1}, _Term]}=I0],
+ #b_ret{arg=Dst}, Hs) ->
+ ThrownType = beam_ssa:get_anno(thrown_type, I0, any),
+ I = opt_throw(Hs, ThrownType, I0),
+ [I];
+opt_is([I | Is], Last, Hs) ->
+ [I | opt_is(Is, Last, Hs)];
+opt_is([], _Last, _Hs) ->
+ [].
+
+opt_throw([suitable | Hs], ThrownType, I) ->
+ opt_throw(Hs, ThrownType, I);
+opt_throw([{tentative, Start, Vars, Blocks} | Hs], ThrownType, I) ->
+ case opt_is_suitable(Start, Blocks, Vars, ThrownType) of
+ true -> opt_throw(Hs, ThrownType, I);
+ false -> I
+ end;
+opt_throw([], _ThrownType, #b_set{args=[_, Reason]}=I) ->
+ %% All handlers caught us and ignored our stack trace. Rewrite ourselves to
+ %% erlang:raise/3 with an empty stack trace.
+ MFA = #b_remote{mod=#b_literal{val=erlang},
+ name=#b_literal{val=raise},
+ arity=3},
+ Stacktrace = #b_literal{val=[]},
+ I#b_set{args=[MFA, #b_literal{val=throw}, Reason, Stacktrace]}.
+
+%% Checks whether we avoid building a stack trace when entering the handler
+%% with the given throw type ("reason").
+%%
+%% The analysis is similar to that of the type pass, and I'd liked to have used
+%% that more directly but it would require much more work for little benefit;
+%% the watered-down version below is good enough to handle the most common
+%% cases.
+opt_is_suitable(Start, Blocks, Vars, ThrownType) ->
+ Ts = ois_init_ts(Vars, ThrownType),
+ ois_1([Start], Blocks, Ts).
+
+ois_1([Lbl | Lbls], Blocks, Ts0) ->
+ case Blocks of
+ #{ Lbl := #b_blk{last=Last,is=Is} } ->
+ case ois_is(Is, Ts0) of
+ {ok, Ts} ->
+ Next = ois_successors(Last, Ts),
+ ois_1(Next ++ Lbls, Blocks, Ts);
+ error ->
+ false
+ end;
+ #{} ->
+ ois_1(Lbls, Blocks, Ts0)
+ end;
+ois_1([], _Blocks, _Ts) ->
+ true.
+
+ois_successors(#b_switch{fail=Fail,list=List}, _Ts) ->
+ Lbls = [Lbl || {_, Lbl} <- List],
+ [Fail | Lbls];
+ois_successors(#b_br{bool=Bool,succ=Succ,fail=Fail}, Ts) ->
+ case beam_types:get_singleton_value(ois_get_type(Bool, Ts)) of
+ {ok, true} -> [Succ];
+ {ok, false} -> [Fail];
+ error -> [Succ, Fail]
+ end.
+
+ois_init_ts({Class, Reason, Stacktrace}, ThrownType) ->
+ Ts = #{ Class => beam_types:make_atom(throw),
+ Reason => ThrownType,
+ Stacktrace => any },
+ maps:remove(none, Ts).
+
+ois_is([#b_set{op=build_stacktrace} | _], _Ts) ->
+ error;
+ois_is([#b_set{op=raw_raise} | _], _Ts) ->
+ error;
+ois_is([#b_set{op=resume} | _], _Ts) ->
+ error;
+ois_is([#b_set{op=get_hd,dst=Dst,args=[Src]} | Is], Ts0) ->
+ SrcType = ois_get_type(Src, Ts0),
+ {Type, _, _} = beam_call_types:types(erlang, hd, [SrcType]),
+ Ts = Ts0#{ Dst => Type },
+ ois_is(Is, Ts);
+ois_is([#b_set{op=get_tl,dst=Dst,args=[Src]} | Is], Ts0) ->
+ SrcType = ois_get_type(Src, Ts0),
+ {Type, _, _} = beam_call_types:types(erlang, tl, [SrcType]),
+ Ts = Ts0#{ Dst => Type },
+ ois_is(Is, Ts);
+ois_is([#b_set{op=get_tuple_element,dst=Dst,args=[Src, Offset]} | Is], Ts0) ->
+ Type = case Ts0 of
+ #{ Src := #t_tuple{size=Size,elements=Es} } ->
+ #b_literal{val=N} = Offset,
+ true = Size > N, %Assertion.
+ beam_types:get_tuple_element(N + 1, Es);
+ #{} ->
+ any
+ end,
+ Ts = Ts0#{ Dst => Type },
+ ois_is(Is, Ts);
+ois_is([#b_set{op={bif,is_atom},dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, #t_atom{}, Is, Ts);
+ois_is([#b_set{op={bif,is_bitstring},dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, #t_bitstring{}, Is, Ts);
+ois_is([#b_set{op={bif,is_binary},dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, #t_bitstring{size_unit=8}, Is, Ts);
+ois_is([#b_set{op={bif,is_float},dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, #t_float{}, Is, Ts);
+ois_is([#b_set{op={bif,is_integer},dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, #t_integer{}, Is, Ts);
+ois_is([#b_set{op={bif,is_list},dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, #t_list{}, Is, Ts);
+ois_is([#b_set{op={bif,is_map},dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, #t_map{}, Is, Ts);
+ois_is([#b_set{op={bif,is_number},dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, number, Is, Ts);
+ois_is([#b_set{op={bif,is_tuple},dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, #t_tuple{}, Is, Ts);
+ois_is([#b_set{op=is_nonempty_list,dst=Dst,args=[Src]} | Is], Ts) ->
+ ois_type_test(Src, Dst, #t_cons{}, Is, Ts);
+ois_is([#b_set{op=is_tagged_tuple,dst=Dst,args=[Src, Size, Tag]} | Is], Ts) ->
+ Es = beam_types:set_tuple_element(1, ois_get_type(Tag, Ts), #{}),
+ #b_literal{val=N} = Size,
+
+ Type = #t_tuple{exact=true,size=N,elements=Es},
+
+ ois_type_test(Src, Dst, Type, Is, Ts);
+ois_is([#b_set{op={bif,tuple_size},dst=Dst,args=[Src]} | Is], Ts0) ->
+ SrcType = ois_get_type(Src, Ts0),
+ {Type, _, _} = beam_call_types:types(erlang, tuple_size, [SrcType]),
+ Ts = Ts0#{ Dst => Type },
+ ois_is(Is, Ts);
+ois_is([#b_set{op={bif,'=:='},
+ dst=Dst,
+ args=[LHS,#b_literal{val=RHS}]} | Is], Ts0) ->
+ Type = case beam_types:get_singleton_value(ois_get_type(LHS, Ts0)) of
+ {ok, RHS} -> beam_types:make_atom(true);
+ {ok, _Other} -> beam_types:make_atom(false);
+ error -> beam_types:make_boolean()
+ end,
+ Ts = Ts0#{ Dst => Type },
+ ois_is(Is, Ts);
+ois_is([#b_set{} | Is], Ts) ->
+ ois_is(Is, Ts);
+ois_is([], Ts) ->
+ {ok, Ts}.
+
+ois_type_test(Src, Dst, RequiredType, Is, Ts0) ->
+ GivenType = ois_get_type(Src, Ts0),
+ Type = case beam_types:meet(GivenType, RequiredType) of
+ GivenType -> beam_types:make_atom(true);
+ none -> beam_types:make_atom(false);
+ _Other -> beam_types:make_boolean()
+ end,
+ Ts = Ts0#{ Dst => Type },
+ ois_is(Is, Ts).
+
+ois_get_type(#b_literal{val=Value}, _Ts) ->
+ beam_types:make_type_from_value(Value);
+ois_get_type(#b_var{}=Arg, Ts) ->
+ case Ts of
+ #{ Arg := Type } -> Type;
+ #{} -> any
+ end.
diff --git a/lib/compiler/src/beam_ssa_type.erl b/lib/compiler/src/beam_ssa_type.erl
index 1e4c9ba5a0..232a5daf16 100644
--- a/lib/compiler/src/beam_ssa_type.erl
+++ b/lib/compiler/src/beam_ssa_type.erl
@@ -931,16 +931,11 @@ simplify(#b_set{op=put_tuple,args=Args}=I, _Ts) ->
end;
simplify(#b_set{op=wait_timeout,args=[#b_literal{val=0}]}, _Ts) ->
#b_literal{val=true};
-simplify(#b_set{op=call,args=[#b_remote{}=Rem|Args]}=I, _Ts) ->
+simplify(#b_set{op=call,args=[#b_remote{}=Rem|Args]}=I, Ts) ->
case Rem of
#b_remote{mod=#b_literal{val=Mod},
name=#b_literal{val=Name}} ->
- case erl_bifs:is_pure(Mod, Name, length(Args)) of
- true ->
- simplify_remote_call(Mod, Name, Args, I);
- false ->
- I
- end;
+ simplify_remote_call(Mod, Name, Args, Ts, I);
#b_remote{} ->
I
end;
@@ -1154,13 +1149,17 @@ phi_all_same_1([], _Arg) ->
phi_all_same_1(_Phis, _Arg) ->
false.
-%% Simplify a remote call to a pure BIF.
-simplify_remote_call(erlang, '++', [#b_literal{val=[]},Tl], _I) ->
+simplify_remote_call(erlang, throw, [Term], Ts, I) ->
+ %% Annotate `throw` instructions with the type of their thrown term,
+ %% helping `beam_ssa_throw` optimize non-local returns.
+ Type = normalized_type(Term, Ts),
+ beam_ssa:add_anno(thrown_type, Type, I);
+simplify_remote_call(erlang, '++', [#b_literal{val=[]},Tl], _Ts, _I) ->
Tl;
simplify_remote_call(erlang, setelement,
[#b_literal{val=Pos},
#b_literal{val=Tuple},
- #b_var{}=Value], I)
+ #b_var{}=Value], _Ts, I)
when is_integer(Pos), 1 =< Pos, Pos =< tuple_size(Tuple) ->
%% Position is a literal integer and the shape of the
%% tuple is known.
@@ -1168,7 +1167,16 @@ simplify_remote_call(erlang, setelement,
{Bef,[_|Aft]} = split(Pos - 1, Els0),
Els = Bef ++ [Value|Aft],
I#b_set{op=put_tuple,args=Els};
-simplify_remote_call(Mod, Name, Args0, I) ->
+simplify_remote_call(Mod, Name, Args, _Ts, I) ->
+ case erl_bifs:is_pure(Mod, Name, length(Args)) of
+ true ->
+ simplify_pure_call(Mod, Name, Args, I);
+ false ->
+ I
+ end.
+
+%% Simplify a remote call to a pure BIF.
+simplify_pure_call(Mod, Name, Args0, I) ->
case make_literal_list(Args0) of
none ->
I;
diff --git a/lib/compiler/src/compile.erl b/lib/compiler/src/compile.erl
index 8a3e1c6cd3..e08b444a13 100644
--- a/lib/compiler/src/compile.erl
+++ b/lib/compiler/src/compile.erl
@@ -874,6 +874,10 @@ kernel_passes() ->
{iff,dssaopt,{listing,"ssaopt"}},
{unless,no_ssa_opt,{iff,ssalint,{pass,beam_ssa_lint}}},
+ {unless,no_throw_opt,{pass,beam_ssa_throw}},
+ {iff,dthrow,{listing,"throw"}},
+ {unless,no_throw_opt,{iff,ssalint,{pass,beam_ssa_lint}}},
+
{unless,no_recv_opt,{pass,beam_ssa_recv}},
{iff,drecv,{listing,"recv"}},
{unless,no_recv_opt,{iff,ssalint,{pass,beam_ssa_lint}}}]},
@@ -2173,6 +2177,7 @@ pre_load() ->
beam_ssa_pre_codegen,
beam_ssa_recv,
beam_ssa_share,
+ beam_ssa_throw,
beam_ssa_type,
beam_trim,
beam_types,
diff --git a/lib/compiler/src/compiler.app.src b/lib/compiler/src/compiler.app.src
index 92e9fa74e5..9ab9553283 100644
--- a/lib/compiler/src/compiler.app.src
+++ b/lib/compiler/src/compiler.app.src
@@ -47,6 +47,7 @@
beam_ssa_pre_codegen,
beam_ssa_recv,
beam_ssa_share,
+ beam_ssa_throw,
beam_ssa_type,
beam_trim,
beam_types,
diff --git a/lib/compiler/test/trycatch_SUITE.erl b/lib/compiler/test/trycatch_SUITE.erl
index 9b4a7754b3..8695946409 100644
--- a/lib/compiler/test/trycatch_SUITE.erl
+++ b/lib/compiler/test/trycatch_SUITE.erl
@@ -1526,6 +1526,7 @@ expr_export_5() ->
coverage(_Config) ->
{'EXIT',{{badfun,true},[_|_]}} = (catch coverage_1()),
+ ok = coverage_ssa_throw(),
ok.
%% Cover some code in beam_trim.
@@ -1543,5 +1544,77 @@ coverage_1() ->
true
end.
+%% Cover some code in beam_ssa_throw.
+coverage_ssa_throw() ->
+ cst_trivial(),
+ cst_raw(),
+ cst_stacktrace(),
+ cst_types(),
+
+ ok.
+
+cst_trivial() ->
+ %% never inspects stacktrace
+ try
+ cst_trivial_1()
+ catch
+ _C:_R:_S ->
+ ok
+ end.
+
+cst_trivial_1() -> throw(id(gurka)).
+
+cst_types() ->
+ %% type tests
+ try
+ cst_types_1()
+ catch
+ throw:Val when is_atom(Val);
+ is_bitstring(Val);
+ is_binary(Val);
+ is_float(Val);
+ is_integer(Val);
+ is_list(Val);
+ is_map(Val);
+ is_number(Val);
+ is_tuple(Val) ->
+ ok;
+ throw:[_|_]=Cons when hd(Cons) =/= gurka;
+ tl(Cons) =/= gaffel ->
+ %% is_nonempty_list, get_hd, get_tl
+ ok;
+ throw:Tuple when tuple_size(Tuple) < 5 ->
+ %% tuple_size
+ ok
+ end.
+
+cst_types_1() -> throw(id(gurka)).
+
+cst_stacktrace() ->
+ %% build_stacktrace
+ try
+ cst_stacktrace_1()
+ catch
+ throw:gurka ->
+ ok;
+ _C:_R:Stack ->
+ id(Stack),
+ ok
+ end.
+
+cst_stacktrace_1() -> throw(id(gurka)).
+
+cst_raw() ->
+ %% raw_raise
+ try
+ cst_raw_1()
+ catch
+ throw:gurka ->
+ ok;
+ _C:_R:Stack ->
+ erlang:raise(error, dummy, Stack)
+ end.
+
+cst_raw_1() -> throw(id(gurka)).
id(I) -> I.
--
2.26.2
