Merge branch 'bjorn/compiler/coverage-and-minor-fixes/OTP-9982' into maint

* bjorn/compiler/coverage-and-minor-fixes/OTP-9982:
  v3_life: Use common code for guards and bodies
  v3_core: Don't put negative line numbers in annotations
  v3_kernel: Dig out the line number only when generating a warning
  v3_kernel: Clean up handling of guards
  v3_kernel: Introduce is_in_guard/1
  v3_kernel: Removed unreached clause for #k_bin_int{} in sub_size_var/1
  v3_kernel: Remove unreached handling of #k_bin_int{} in arg_con/1
  v3_codegen: Eliminate the special case of 'put' without destination
  v3_kernel: Don't attempt to share identical literals
  v3_kernel: Handle sequences in guards
  v3_kernel: Remove clauses that are never executed in arg_val/1
  v3_kernel.hrl: Remove unused record #k_string{}
  v3_kernel.erl: Remove unused define of EXPENSIVE_BINARY_LIMIT
  sys_core_fold: Refactor previous_ctx_to_binary/2 to cover it completely
  sys_core_fold: Fix opt_guard_try/1
  sys_core_fold: Simplify opt_bool_not() to cover it completely
  sys_core_fold: Remove duplicate optimization

6 files changed, 176 insertions, 324 deletions

diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index 5b155398dc..4e67639805 100644
--- a/lib/compiler/src/sys_core_fold.erl
+++ b/lib/compiler/src/sys_core_fold.erl
@@ -150,14 +150,26 @@ guard(Expr, Sub) ->
 opt_guard_try(#c_seq{arg=Arg,body=Body0}=Seq) ->
     Body = opt_guard_try(Body0),
     case {Arg,Body} of
-	{#c_call{},#c_literal{val=false}} ->
-	    %% We have sequence consisting of a call (evaluted
-	    %% for a possible exception only), followed by 'false'.
-	    %% Since the sequence is inside a try block that will
+	{#c_call{module=#c_literal{val=Mod},
+		 name=#c_literal{val=Name},
+		 args=Args},#c_literal{val=false}} ->
+	    %% We have sequence consisting of a call (evaluated
+	    %% for a possible exception and/or side effect only),
+	    %% followed by 'false'.
+	    %%   Since the sequence is inside a try block that will
 	    %% default to 'false' if any exception occurs, not
 	    %% evalutating the call will not change the behaviour
-	    %% of the guard.
-	    Body;
+	    %% provided that the call has no side effects.
+	    case erl_bifs:is_pure(Mod, Name, length(Args)) of
+		false ->
+		    %% Not a pure BIF (meaning that this is not
+		    %% a guard and that we must keep the call).
+		    Seq#c_seq{body=Body};
+		true ->
+		    %% The BIF has no side effects, so it can
+		    %% be safely removed.
+		    Body
+	    end;
 	{_,_} ->
 	    Seq#c_seq{body=Body}
     end;
@@ -1747,36 +1759,26 @@ opt_bool_clauses([_|_], _, _) ->
 %%     end.			       NewVar ->
 %%                                        erlang:error(badarg)
 %%                                  end.
-%%
-%%  We add the extra match-all clause at the end only if Expr is
-%%  not guaranteed to evaluate to a boolean.
 
 opt_bool_not(#c_case{arg=Arg,clauses=Cs0}=Case0) ->
     case Arg of
 	#c_call{anno=Anno,module=#c_literal{val=erlang},
  		name=#c_literal{val='not'},
  		args=[Expr]} ->
-	    Cs = opt_bool_not(Anno, Expr, Cs0),
+	    Cs = [opt_bool_not_invert(C) || C <- Cs0] ++
+		 [#c_clause{anno=[compiler_generated],
+			    pats=[#c_var{name=cor_variable}],
+			    guard=#c_literal{val=true},
+			    body=#c_call{anno=Anno,
+					 module=#c_literal{val=erlang},
+					 name=#c_literal{val=error},
+					 args=[#c_literal{val=badarg}]}}],
 	    Case = Case0#c_case{arg=Expr,clauses=Cs},
 	    opt_bool_not(Case);
 	_ ->
 	    opt_bool_case_redundant(Case0)
     end.
 
-opt_bool_not(Anno, Expr, Cs) ->
-    Tail = case is_bool_expr(Expr) of
-	       false ->
-		   [#c_clause{anno=[compiler_generated],
-			      pats=[#c_var{name=cor_variable}],
-			      guard=#c_literal{val=true},
-			      body=#c_call{anno=Anno,
-					   module=#c_literal{val=erlang},
-					   name=#c_literal{val=error},
-					   args=[#c_literal{val=badarg}]}}];
-	       true -> []
-	   end,
-    [opt_bool_not_invert(C) || C <- Cs] ++ Tail.
-
 opt_bool_not_invert(#c_clause{pats=[#c_literal{val=Bool}]}=C) ->
     C#c_clause{pats=[#c_literal{val=not Bool}]}.
 
@@ -2065,32 +2067,7 @@ opt_case_in_let_2(V, Arg0,
 		   (_) -> false end, Es),	%Only variables in tuple
     false = core_lib:is_var_used(V, B),		%Built tuple must not be used.
     Arg1 = tuple_to_values(Arg0, length(Es)),	%Might fail.
-    #c_let{vars=Es,arg=Arg1,body=B};
-opt_case_in_let_2(_, Arg, Cs) ->
-    %% simplify_bool_case(Case0) -> Case
-    %%  Remove unecessary cases like
-    %%
-    %%     case BoolExpr of
-    %%       true -> true;
-    %%       false -> false;
-    %%       ....
-    %%     end
-    %%
-    %%  where BoolExpr is an expression that can only return true
-    %%  or false (or throw an exception).
-
-    true = is_bool_case(Cs) andalso is_bool_expr(Arg),
-    Arg.
-
-is_bool_case([A,B|_]) ->
-    (is_bool_clause(true, A) andalso is_bool_clause(false, B))
-	orelse (is_bool_clause(false, A) andalso is_bool_clause(true, B)).
-
-is_bool_clause(Bool, #c_clause{pats=[#c_literal{val=Bool}],
-			       guard=#c_literal{val=true},
-			       body=#c_literal{val=Bool}}) ->
-    true;
-is_bool_clause(_, _) -> false.
+    #c_let{vars=Es,arg=Arg1,body=B}.
 
 %% is_simple_case_arg(Expr) -> true|false
 %%  Determine whether the Expr is simple enough to be worth
@@ -2612,14 +2589,14 @@ bsm_maybe_ctx_to_binary(V, B) ->
 		   body=B}
     end.
 
-previous_ctx_to_binary(V, #c_seq{arg=#c_primop{name=Name,args=As}}) ->
-    case {Name,As} of
-	{#c_literal{val=bs_context_to_binary},[#c_var{name=V}]} ->
+previous_ctx_to_binary(V, Core) ->
+    case Core of
+	#c_seq{arg=#c_primop{name=#c_literal{val=bs_context_to_binary},
+			     args=[#c_var{name=V}]}} ->
 	    true;
-	{_,_} ->
+	_ ->
 	    false
-    end;
-previous_ctx_to_binary(_, _) -> false.
+    end.
 
 %% bsm_leftmost(Cs) -> none | ArgumentNumber
 %%  Find the leftmost argument that does binary matching. Return
@@ -2764,22 +2741,20 @@ add_bin_opt_info(Core, Term) ->
     end.
 
 add_warning(Core, Term) ->
-    Anno = core_lib:get_anno(Core),
-    case lists:member(compiler_generated, Anno) of
-	true -> ok;
+    case is_compiler_generated(Core) of
+	true ->
+	    ok;
 	false ->
-	    case get_line(Anno) of
-		Line when Line >= 0 ->		%Must be positive.
-                    File = get_file(Anno),
-		    Key = {?MODULE,warnings},
-		    case get(Key) of
-			[{File,[{Line,?MODULE,Term}]}|_] ->
-			    ok;			%We already have 
+	    Anno = core_lib:get_anno(Core),
+	    Line = get_line(Anno),
+	    File = get_file(Anno),
+	    Key = {?MODULE,warnings},
+	    case get(Key) of
+		[{File,[{Line,?MODULE,Term}]}|_] ->
+		    ok;				%We already have
 						%an identical warning.
-			Ws ->
-			    put(Key, [{File,[{Line,?MODULE,Term}]}|Ws])
-		    end;
-		_ -> ok				%Compiler-generated code.
+		Ws ->
+		    put(Key, [{File,[{Line,?MODULE,Term}]}|Ws])
 	    end
     end.
 
@@ -2793,14 +2768,7 @@ get_file([]) -> "no_file". % should not happen
 
 is_compiler_generated(Core) ->
     Anno = core_lib:get_anno(Core),
-    case lists:member(compiler_generated, Anno) of
-	true -> true;
-	false ->
-	    case get_line(Anno) of
-		Line when Line >= 0 -> false;
-		_ -> true
-	    end
-    end.
+    member(compiler_generated, Anno).
 
 get_warnings() ->
     ordsets:from_list((erase({?MODULE,warnings}))).
diff --git a/lib/compiler/src/v3_codegen.erl b/lib/compiler/src/v3_codegen.erl
index 6623485609..36d35a8122 100644
--- a/lib/compiler/src/v3_codegen.erl
+++ b/lib/compiler/src/v3_codegen.erl
@@ -1423,20 +1423,7 @@ set_cg([{var,R}], Con, Le, Vdb, Bef, St) ->
 	      Other ->
 		  [{move,Other,Ret}]
 	  end,
-    {Ais,clear_dead(Int, Le#l.i, Vdb),St};
-set_cg([], {binary,Segs}, Le, Vdb, Bef, St) ->
-    Fail = {f,St#cg.bfail},
-    Target = find_scratch_reg(Bef#sr.reg),
-    Temp = find_scratch_reg(put_reg(Target, Bef#sr.reg)),
-    PutCode = cg_bin_put(Segs, Fail, Bef),
-    MaxRegs = max_reg(Bef#sr.reg),
-    Code = cg_binary(PutCode, Target, Temp, Fail, MaxRegs, Le#l.a),
-    Aft = clear_dead(Bef, Le#l.i, Vdb),
-    {Code,Aft,St};
-set_cg([], _, Le, Vdb, Bef, St) ->
-    %% This should have been stripped by compiler, just cleanup.
-    {[],clear_dead(Bef, Le#l.i, Vdb), St}.
-
+    {Ais,clear_dead(Int, Le#l.i, Vdb),St}.
 
 %%%
 %%% Code generation for constructing binaries.
@@ -2067,7 +2054,7 @@ line_1(_, 0) ->
     %% Missing line number or line number 0.
     {line,[]};
 line_1(Name, Line) ->
-    {line,[{location,Name,abs(Line)}]}.
+    {line,[{location,Name,Line}]}.
 
 find_loc([Line|T], File, _) when is_integer(Line) ->
     find_loc(T, File, Line);
diff --git a/lib/compiler/src/v3_core.erl b/lib/compiler/src/v3_core.erl
index 6885405ae0..ad0a8a7654 100644
--- a/lib/compiler/src/v3_core.erl
+++ b/lib/compiler/src/v3_core.erl
@@ -2085,7 +2085,12 @@ bitstr_vars(Segs, Vs) ->
 
 lineno_anno(L, St) ->
     {line, Line} = erl_parse:get_attribute(L, line),
-    [Line] ++ St#core.file.
+    if
+	Line < 0 ->
+	    [-Line] ++ St#core.file ++ [compiler_generated];
+	true ->
+	    [Line] ++ St#core.file
+    end.
 
 get_ianno(Ce) ->
     case get_anno(Ce) of
diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index f2eaa37617..abe94ad991 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -88,8 +88,6 @@
 -include("core_parse.hrl").
 -include("v3_kernel.hrl").
 
--define(EXPENSIVE_BINARY_LIMIT, 256).
-
 %% These are not defined in v3_kernel.hrl.
 get_kanno(Kthing) -> element(2, Kthing).
 set_kanno(Kthing, Anno) -> setelement(2, Kthing, Anno).
@@ -120,7 +118,6 @@ copy_anno(Kdst, Ksrc) ->
 	       funs=[],				%Fun functions
 	       free=[],				%Free variables
 	       ws=[]   :: [warning()],		%Warnings.
-	       lit,			        %Constant pool for literals.
 	       guard_refc=0}).			%> 0 means in guard
 
 -spec module(cerl:c_module(), [compile:option()]) ->
@@ -129,7 +126,7 @@ copy_anno(Kdst, Ksrc) ->
 module(#c_module{anno=A,name=M,exports=Es,attrs=As,defs=Fs}, _Options) ->
     Kas = attributes(As),
     Kes = map(fun (#c_var{name={_,_}=Fname}) -> Fname end, Es),
-    St0 = #kern{lit=dict:new()},
+    St0 = #kern{},
     {Kfs,St} = mapfoldl(fun function/2, St0, Fs),
     {ok,#k_mdef{anno=A,name=M#c_literal.val,exports=Kes,attributes=Kas,
 		body=Kfs ++ St#kern.funs},lists:sort(St#kern.ws)}.
@@ -250,26 +247,20 @@ expr(#c_var{anno=A,name={_Name,Arity}}=Fname, Sub, St) ->
     expr(Fun, Sub, St);
 expr(#c_var{anno=A,name=V}, Sub, St) ->
     {#k_var{anno=A,name=get_vsub(V, Sub)},[],St};
-expr(#c_literal{}=Lit, Sub, St) ->
-    Core = handle_literal(Lit),
-    expr(Core, Sub, St);
-expr(#k_literal{val=Val0}=Klit, _Sub, #kern{lit=Literals0}=St) ->
-    %% Share identical literals to save some space and time during compilation.
-    case dict:find(Val0, Literals0) of
-	{ok,Val} ->
-	    {Klit#k_literal{val=Val},[],St};
-	error ->
-	    Literals = dict:store(Val0, Val0, Literals0),
-	    {Klit,[],St#kern{lit=Literals}}
-    end;
-expr(#k_nil{}=V, _Sub, St) ->
-    {V,[],St};
-expr(#k_int{}=V, _Sub, St) ->
-    {V,[],St};
-expr(#k_float{}=V, _Sub, St) ->
-    {V,[],St};
-expr(#k_atom{}=V, _Sub, St) ->
-    {V,[],St};
+expr(#c_literal{anno=A,val=V}, _Sub, St) ->
+    Klit = case V of
+	       [] ->
+		   #k_nil{anno=A};
+	       V when is_integer(V) ->
+		   #k_int{anno=A,val=V};
+	       V when is_float(V) ->
+		   #k_float{anno=A,val=V};
+	       V when is_atom(V) ->
+		   #k_atom{anno=A,val=V};
+	       _ ->
+		   #k_literal{anno=A,val=V}
+	   end,
+    {Klit,[],St};
 expr(#c_cons{anno=A,hd=Ch,tl=Ct}, Sub, St0) ->
     %% Do cons in two steps, first the expressions left to right, then
     %% any remaining literals right to left.
@@ -610,7 +601,6 @@ is_atomic(#k_int{}) -> true;
 is_atomic(#k_float{}) -> true;
 is_atomic(#k_atom{}) -> true;
 %%is_atomic(#k_char{}) -> true;			%No characters
-%%is_atomic(#k_string{}) -> true;
 is_atomic(#k_nil{}) -> true;
 is_atomic(#k_var{}) -> true;
 is_atomic(_) -> false.
@@ -919,9 +909,8 @@ match_guard_1([#iclause{anno=A,osub=Osub,guard=G,body=B}|Cs0], Def0, St0) ->
 	true ->
 	    %% The true clause body becomes the default.
 	    {Kb,Pb,St1} = body(B, Osub, St0),
-	    Line = get_line(A),
-	    St2 = maybe_add_warning(Cs0, Line, St1),
-	    St = maybe_add_warning(Def0, Line, St2),
+	    St2 = maybe_add_warning(Cs0, A, St1),
+	    St = maybe_add_warning(Def0, A, St2),
 	    {[],pre_seq(Pb, Kb),St};
 	false ->
 	    {Kg,St1} = guard(G, Osub, St0),
@@ -932,15 +921,18 @@ match_guard_1([#iclause{anno=A,osub=Osub,guard=G,body=B}|Cs0], Def0, St0) ->
     end;
 match_guard_1([], Def, St) -> {[],Def,St}. 
 
-maybe_add_warning([C|_], Line, St) ->
-    maybe_add_warning(C, Line, St);
-maybe_add_warning([], _Line, St) -> St;
-maybe_add_warning(fail, _Line, St) -> St;
-maybe_add_warning(Ke, MatchLine, St) ->
-    case get_kanno(Ke) of
-	[compiler_generated|_] -> St;
-	Anno ->
+maybe_add_warning([C|_], MatchAnno, St) ->
+    maybe_add_warning(C, MatchAnno, St);
+maybe_add_warning([], _MatchAnno, St) -> St;
+maybe_add_warning(fail, _MatchAnno, St) -> St;
+maybe_add_warning(Ke, MatchAnno, St) ->
+    case is_compiler_generated(Ke) of
+	true ->
+	    St;
+	false ->
+	    Anno = get_kanno(Ke),
 	    Line = get_line(Anno),
+	    MatchLine = get_line(MatchAnno),
 	    Warn = case MatchLine of
 		       none -> nomatch_shadow;
 		       _ -> {nomatch_shadow,MatchLine}
@@ -1122,7 +1114,6 @@ select_bin_int([#iclause{pats=[#k_bin_seg{anno=A,type=integer,
     end,
     select_assert_match_possible(Bits, Val, Fl),
     P = #k_bin_int{anno=A,size=Sz,unit=U,flags=Fl,val=Val,next=N},
-    select_assert_match_possible(Bits, Val, Fl),
     case member(native, Fl) of
 	true -> throw(not_possible);
 	false -> ok
@@ -1264,8 +1255,6 @@ match_clause([U|Us], [C|_]=Cs0, Def, St0) ->
 
 sub_size_var(#k_bin_seg{size=#k_var{name=Name}=Kvar}=BinSeg, [#iclause{isub=Sub}|_]) ->
     BinSeg#k_bin_seg{size=Kvar#k_var{name=get_vsub(Name, Sub)}};
-sub_size_var(#k_bin_int{size=#k_var{name=Name}=Kvar}=BinSeg, [#iclause{isub=Sub}|_]) ->
-    BinSeg#k_bin_int{size=Kvar#k_var{name=get_vsub(Name, Sub)}};
 sub_size_var(K, _) -> K.
 
 get_con([C|_]) -> arg_arg(clause_arg(C)).	%Get the constructor
@@ -1383,7 +1372,6 @@ arg_con(Arg) ->
 	#k_tuple{} -> k_tuple;
 	#k_binary{} -> k_binary;
 	#k_bin_end{} -> k_bin_end;
-	#k_bin_int{} -> k_bin_int;
 	#k_bin_seg{} -> k_bin_seg;
 	#k_var{} -> k_var
     end.
@@ -1394,15 +1382,9 @@ arg_val(Arg) ->
 	#k_int{val=I} -> I;
 	#k_float{val=F} -> F;
 	#k_atom{val=A} -> A;
-	#k_nil{} -> 0;
-	#k_cons{} -> 2; 
 	#k_tuple{es=Es} -> length(Es);
 	#k_bin_seg{size=S,unit=U,type=T,flags=Fs} ->
-	    {set_kanno(S, []),U,T,Fs};
-	#k_bin_int{} ->
-	    0;
-	#k_bin_end{} -> 0;
-	#k_binary{} -> 0
+	    {set_kanno(S, []),U,T,Fs}
     end.
 
 %% ubody_used_vars(Expr, State) -> [UsedVar]
@@ -1432,14 +1414,12 @@ ubody(#ivalues{anno=A,args=As}, return, St) ->
     {#k_return{anno=#k{us=Au,ns=[],a=A},args=As},Au,St};
 ubody(#ivalues{anno=A,args=As}, {break,_Vbs}, St) ->
     Au = lit_list_vars(As),
-    if St#kern.guard_refc > 0 ->
+    case is_in_guard(St) of
+	true ->
 	    {#k_guard_break{anno=#k{us=Au,ns=[],a=A},args=As},Au,St};
-       true ->
+	false ->
 	    {#k_break{anno=#k{us=Au,ns=[],a=A},args=As},Au,St}
     end;
-ubody(#ivalues{anno=A,args=As}, {guard_break,_Vbs}, St) ->
-    Au = lit_list_vars(As),
-    {#k_guard_break{anno=#k{us=Au,ns=[],a=A},args=As},Au,St};
 ubody(E, return, St0) ->
     %% Enterable expressions need no trailing return.
     case is_enter_expr(E) of
@@ -1456,12 +1436,7 @@ ubody(E, {break,_Rs} = Break, St0) ->
 	false ->
 	    {Ea,Pa,St1} = force_atomic(E, St0),
 	    ubody(pre_seq(Pa, #ivalues{args=[Ea]}), Break, St1)
-    end;
-ubody(E, {guard_break,_Rs} = GuardBreak, St0) ->
-    %%ok = io:fwrite("ubody ~w:~p~n", [?LINE,{E,Br}]),
-    %% Exiting expressions need no trailing break.
-    {Ea,Pa,St1} = force_atomic(E, St0),
-    ubody(pre_seq(Pa, #ivalues{args=[Ea]}), GuardBreak, St1).
+    end.
 
 iletrec_funs(#iletrec{defs=Fs}, St0) ->
     %% Use union of all free variables.
@@ -1513,64 +1488,21 @@ is_enter_expr(#k_receive{}) -> true;
 is_enter_expr(#k_receive_next{}) -> true;
 is_enter_expr(_) -> false.
 
-%% uguard(Expr, State) -> {Expr,[UsedVar],State}.
-%%  Tag the guard sequence with its used variables.
-
-uguard(#k_try{anno=A,arg=B0,vars=[#k_var{name=X}],body=#k_var{name=X},
-	      handler=#k_atom{val=false}}=Try, St0) ->
-    {B1,Bu,St1} = uguard(B0, St0),
-    {Try#k_try{anno=#k{us=Bu,ns=[],a=A},arg=B1},Bu,St1};
-uguard(T, St) ->
-    %%ok = io:fwrite("~w: ~p~n", [?LINE,T]),
-    uguard_test(T, St).
-
-%% uguard_test(Expr, State) -> {Test,[UsedVar],State}.
-%%  At this stage tests are just expressions which don't return any
-%%  values.
-
-uguard_test(T, St) -> uguard_expr(T, [], St).
+%% uexpr(Expr, Break, State) -> {Expr,[UsedVar],State}.
+%%  Tag an expression with its used variables.
+%%  Break = return | {break,[RetVar]}.
 
-uguard_expr(#iset{anno=A,vars=Vs,arg=E0,body=B0}, Rs, St0) ->
-    Ns = lit_list_vars(Vs),
-    {E1,Eu,St1} = uguard_expr(E0, Vs, St0),
-    {B1,Bu,St2} = uguard_expr(B0, Rs, St1),
-    Used = union(Eu, subtract(Bu, Ns)),
-    {#k_seq{anno=#k{us=Used,ns=Ns,a=A},arg=E1,body=B1},Used,St2};
-uguard_expr(#k_try{anno=A,arg=B0,vars=[#k_var{name=X}],body=#k_var{name=X},
-		   handler=#k_atom{val=false}}=Try, Rs, St0) ->
-    {B1,Bu,St1} = uguard_expr(B0, Rs, St0),
-    {Try#k_try{anno=#k{us=Bu,ns=lit_list_vars(Rs),a=A},arg=B1,ret=Rs},
-     Bu,St1};
-uguard_expr(#k_test{anno=A,op=Op,args=As}=Test, Rs, St) ->
+uexpr(#k_test{anno=A,op=Op,args=As}=Test, {break,Rs}, St) ->
     [] = Rs,					%Sanity check
     Used = union(op_vars(Op), lit_list_vars(As)),
     {Test#k_test{anno=#k{us=Used,ns=lit_list_vars(Rs),a=A}},
      Used,St};
-uguard_expr(#k_bif{anno=A,op=Op,args=As}=Bif, Rs, St) ->
-    Used = union(op_vars(Op), lit_list_vars(As)),
-    {Bif#k_bif{anno=#k{us=Used,ns=lit_list_vars(Rs),a=A},ret=Rs},
-     Used,St};
-uguard_expr(#ivalues{anno=A,args=As}, Rs, St) ->
-    Sets = foldr2(fun (V, Arg, Rhs) ->
-			  #iset{anno=A,vars=[V],arg=Arg,body=Rhs}
-		  end, #k_atom{val=true}, Rs, As),
-    uguard_expr(Sets, [], St);
-uguard_expr(#k_match{anno=A,vars=Vs,body=B0}, Rs, St0) ->
-    %% Experimental support for andalso/orelse in guards.
-    Br = {guard_break,Rs},
-    {B1,Bu,St1} = umatch(B0, Br, St0),
-    {#k_guard_match{anno=#k{us=Bu,ns=lit_list_vars(Rs),a=A},
-		    vars=Vs,body=B1,ret=Rs},Bu,St1};
-uguard_expr(Lit, Rs, St) ->
-    %% Transform literals to puts here.
-    Used = lit_vars(Lit),
-    {#k_put{anno=#k{us=Used,ns=lit_list_vars(Rs),a=get_kanno(Lit)},
-	    arg=Lit,ret=Rs},Used,St}.
-
-%% uexpr(Expr, Break, State) -> {Expr,[UsedVar],State}.
-%%  Tag an expression with its used variables.
-%%  Break = return | {break,[RetVar]}.
-
+uexpr(#iset{anno=A,vars=Vs,arg=E0,body=B0}, {break,_}=Br, St0) ->
+    Ns = lit_list_vars(Vs),
+    {E1,Eu,St1} = uexpr(E0, {break,Vs}, St0),
+    {B1,Bu,St2} = uexpr(B0, Br, St1),
+    Used = union(Eu, subtract(Bu, Ns)),
+    {#k_seq{anno=#k{us=Used,ns=Ns,a=A},arg=E1,body=B1},Used,St2};
 uexpr(#k_call{anno=A,op=#k_local{name=F,arity=Ar}=Op,args=As0}=Call, Br, St) ->
     Free = get_free(F, Ar, St),
     As1 = As0 ++ Free,				%Add free variables LAST!
@@ -1602,10 +1534,11 @@ uexpr(#k_match{anno=A,vars=Vs0,body=B0}, Br, St0) ->
     Vs = handle_reuse_annos(Vs0, St0),
     Rs = break_rets(Br),
     {B1,Bu,St1} = umatch(B0, Br, St0),
-    if St0#kern.guard_refc > 0 ->
+    case is_in_guard(St1) of
+	true ->
 	    {#k_guard_match{anno=#k{us=Bu,ns=lit_list_vars(Rs),a=A},
 			    vars=Vs,body=B1,ret=Rs},Bu,St1};
-       true ->
+	false ->
 	    {#k_match{anno=#k{us=Bu,ns=lit_list_vars(Rs),a=A},
 		      vars=Vs,body=B1,ret=Rs},Bu,St1}
     end;
@@ -1622,24 +1555,27 @@ uexpr(#k_receive_accept{anno=A}, _, St) ->
     {#k_receive_accept{anno=#k{us=[],ns=[],a=A}},[],St};
 uexpr(#k_receive_next{anno=A}, _, St) ->
     {#k_receive_next{anno=#k{us=[],ns=[],a=A}},[],St};
-uexpr(#k_try{anno=A,arg=A0,vars=Vs,body=B0,evars=Evs,handler=H0},
-      {break,Rs0}, St0) ->
-    {Avs,St1} = new_vars(length(Vs), St0),	%Need dummy names here
-    {A1,Au,St2} = ubody(A0, {break,Avs}, St1),	%Must break to clean up here!
-    {B1,Bu,St3} = ubody(B0, {break,Rs0}, St2),
-    {H1,Hu,St4} = ubody(H0, {break,Rs0}, St3),
-    %% Guarantee ONE return variable.
-    NumNew = if
-		 Rs0 =:= [] -> 1;
-		 true -> 0
-	     end,
-    {Ns,St5} = new_vars(NumNew, St4),
-    Rs1 = Rs0 ++ Ns,
-    Used = union([Au,subtract(Bu, lit_list_vars(Vs)),
-		  subtract(Hu, lit_list_vars(Evs))]),
-    {#k_try{anno=#k{us=Used,ns=lit_list_vars(Rs1),a=A},
-	    arg=A1,vars=Vs,body=B1,evars=Evs,handler=H1,ret=Rs1},
-     Used,St5};
+uexpr(#k_try{anno=A,arg=A0,vars=Vs,body=B0,evars=Evs,handler=H0}=Try,
+      {break,Rs0}=Br, St0) ->
+    case is_in_guard(St0) of
+	true ->
+	    {[#k_var{name=X}],#k_var{name=X}} = {Vs,B0}, %Assertion.
+	    #k_atom{val=false} = H0,		%Assertion.
+	    {A1,Bu,St1} = uexpr(A0, Br, St0),
+	    {Try#k_try{anno=#k{us=Bu,ns=lit_list_vars(Rs0),a=A},
+		       arg=A1,ret=Rs0},Bu,St1};
+	false ->
+	    {Avs,St1} = new_vars(length(Vs), St0),
+	    {A1,Au,St2} = ubody(A0, {break,Avs}, St1),
+	    {B1,Bu,St3} = ubody(B0, Br, St2),
+	    {H1,Hu,St4} = ubody(H0, Br, St3),
+	    {Rs1,St5} = ensure_return_vars(Rs0, St4),
+	    Used = union([Au,subtract(Bu, lit_list_vars(Vs)),
+			  subtract(Hu, lit_list_vars(Evs))]),
+	    {#k_try{anno=#k{us=Used,ns=lit_list_vars(Rs1),a=A},
+		    arg=A1,vars=Vs,body=B1,evars=Evs,handler=H1,ret=Rs1},
+	     Used,St5}
+    end;
 uexpr(#k_try{anno=A,arg=A0,vars=Vs,body=B0,evars=Evs,handler=H0},
       return, St0) ->
     {Avs,St1} = new_vars(length(Vs), St0),	%Need dummy names here
@@ -1685,12 +1621,13 @@ uexpr(#ifun{anno=A,vars=Vs,body=B0}, {break,Rs}, St0) ->
  		  #k_int{val=Index},#k_int{val=Uniq}|Fvs],
  	    ret=Rs},
      Free,add_local_function(Fun, St)};
-uexpr(Lit, {break,Rs}, St) ->
+uexpr(Lit, {break,Rs0}, St0) ->
     %% Transform literals to puts here.
     %%ok = io:fwrite("uexpr ~w:~p~n", [?LINE,Lit]),
     Used = lit_vars(Lit),
+    {Rs,St1} = ensure_return_vars(Rs0, St0),
     {#k_put{anno=#k{us=Used,ns=lit_list_vars(Rs),a=get_kanno(Lit)},
-	    arg=Lit,ret=Rs},Used,St}.
+	    arg=Lit,ret=Rs},Used,St1}.
 
 add_local_function(_, #kern{funs=ignore}=St) -> St;
 add_local_function(F, #kern{funs=Funs}=St) -> St#kern{funs=[F|Funs]}.
@@ -1747,6 +1684,11 @@ bif_returns(#k_internal{name=N,arity=Ar}, Rs, St0) ->
     {Ns,St1} = new_vars(bif_vals(N, Ar) - length(Rs), St0),
     {Rs ++ Ns,St1}.
 
+%% ensure_return_vars([Ret], State) -> {[Ret],State}.
+
+ensure_return_vars([], St) -> new_vars(1, St);
+ensure_return_vars([_]=Rs, St) -> {Rs,St}.
+
 %% umatch(Match, Break, State) -> {Match,[UsedVar],State}.
 %%  Tag a match expression with its used variables.
 
@@ -1779,7 +1721,8 @@ umatch(#k_guard{anno=A,clauses=Gs0}, Br, St0) ->
     {#k_guard{anno=#k{us=Gus,ns=[],a=A},clauses=Gs1},Gus,St1};
 umatch(#k_guard_clause{anno=A,guard=G0,body=B0}, Br, St0) ->
     %%ok = io:fwrite("~w: ~p~n", [?LINE,G0]),
-    {G1,Gu,St1} = uguard(G0, St0#kern{guard_refc=St0#kern.guard_refc+1}),
+    {G1,Gu,St1} = uexpr(G0, {break,[]},
+			St0#kern{guard_refc=St0#kern.guard_refc+1}),
     %%ok = io:fwrite("~w: ~p~n", [?LINE,G1]),
     {B1,Bu,St2} = umatch(B0, Br, St1#kern{guard_refc=St1#kern.guard_refc-1}),
     Used = union(Gu, Bu),
@@ -1827,7 +1770,6 @@ lit_list_vars(Ps) ->
 
 pat_vars(#k_var{name=N}) -> {[],[N]};
 %%pat_vars(#k_char{}) -> {[],[]};
-%%pat_vars(#k_string{}) -> {[],[]};
 pat_vars(#k_literal{}) -> {[],[]};
 pat_vars(#k_int{}) -> {[],[]};
 pat_vars(#k_float{}) -> {[],[]};
@@ -1854,34 +1796,6 @@ pat_list_vars(Ps) ->
 		  {union(Used0, Used),union(New0, New)} end,
 	  {[],[]}, Ps).
 
-%% handle_literal(Literal, Anno) -> Kernel
-%%  Examine the literal. Complex (heap-based) literals such as lists,
-%%  tuples, and binaries should be kept as literals and put into the constant pool.
-%%
-%%  (If necessary, this function could be extended to go through the literal
-%%  and convert huge binary literals to bit syntax expressions. We don't do that
-%%  because v3_core does not produce huge binary literals, and the optimizations in
-%%  sys_core_fold don't do much optimizations of binaries. IF THAT CHANGE IS MADE,
-%%  ALSO CHANGE sys_core_dsetel.)
-
-handle_literal(#c_literal{anno=A,val=V}) ->
-    case V of
-	[_|_] ->
-	    #k_literal{anno=A,val=V};
-	[] ->
-	    #k_nil{anno=A};
-	V when is_tuple(V) ->
-	    #k_literal{anno=A,val=V};
-	V when is_bitstring(V) ->
-	    #k_literal{anno=A,val=V};
-	V when is_integer(V) ->
-	    #k_int{anno=A,val=V};
-	V when is_float(V) ->
-	    #k_float{anno=A,val=V};
-	V when is_atom(V) ->
-	    #k_atom{anno=A,val=V}
-    end.
-
 make_list(Es) ->
     foldr(fun(E, Acc) ->
  		  #c_cons{hd=E,tl=Acc}
@@ -1893,6 +1807,11 @@ integers(N, M) when N =< M ->
     [N|integers(N + 1, M)];
 integers(_, _) -> [].
 
+%% is_in_guard(State) -> true|false.
+
+is_in_guard(#kern{guard_refc=Refc}) ->
+    Refc > 0.
+
 %%%
 %%% Handling of errors and warnings.
 %%%
@@ -1913,7 +1832,10 @@ format_error(bad_call) ->
 add_warning(none, Term, Anno, #kern{ws=Ws}=St) ->
     File = get_file(Anno),
     St#kern{ws=[{File,[{?MODULE,Term}]}|Ws]};
-add_warning(Line, Term, Anno, #kern{ws=Ws}=St) when Line >= 0 ->
+add_warning(Line, Term, Anno, #kern{ws=Ws}=St) ->
     File = get_file(Anno),
-    St#kern{ws=[{File,[{Line,?MODULE,Term}]}|Ws]};
-add_warning(_, _, _, St) -> St.
+    St#kern{ws=[{File,[{Line,?MODULE,Term}]}|Ws]}.
+
+is_compiler_generated(Ke) ->
+    Anno = get_kanno(Ke),
+    member(compiler_generated, Anno).
diff --git a/lib/compiler/src/v3_kernel.hrl b/lib/compiler/src/v3_kernel.hrl
index 37f2fdcf7e..17904c37da 100644
--- a/lib/compiler/src/v3_kernel.hrl
+++ b/lib/compiler/src/v3_kernel.hrl
@@ -35,7 +35,6 @@
 -record(k_int, {anno=[],val}).
 -record(k_float, {anno=[],val}).
 -record(k_atom, {anno=[],val}).
--record(k_string, {anno=[],val}).
 -record(k_nil, {anno=[]}).
 
 -record(k_tuple, {anno=[],es}).
diff --git a/lib/compiler/src/v3_life.erl b/lib/compiler/src/v3_life.erl
index 93f8034230..22f3e3c2d2 100644
--- a/lib/compiler/src/v3_life.erl
+++ b/lib/compiler/src/v3_life.erl
@@ -112,53 +112,14 @@ guard(#k_try{anno=A,arg=Ts,vars=[#k_var{name=X}],body=#k_var{name=X},
     %% Lock variables that are alive before try and used afterwards.
     %% Don't lock variables that are only used inside the try expression.
     Pdb0 = vdb_sub(I, I+1, Vdb),
-    {T,MaxI,Pdb1} = guard_body(Ts, I+1, Pdb0),
+    {T,MaxI,Pdb1} = body(Ts, I+1, Pdb0),
     Pdb2 = use_vars(A#k.ns, MaxI+1, Pdb1),	%Save "return" values
-    #l{ke={protected,T,var_list(Rs)},i=I,a=A#k.a,vdb=Pdb2};
-guard(#k_seq{}=G, I, Vdb0) ->
-    {Es,_,Vdb1} = guard_body(G, I, Vdb0),
-    #l{ke={block,Es},i=I,vdb=Vdb1,a=[]};
-guard(G, I, Vdb) -> guard_expr(G, I, Vdb).
-
-%% guard_body(Kbody, I, Vdb) -> {[Expr],MaxI,Vdb}.
-
-guard_body(#k_seq{arg=Ke,body=Kb}, I, Vdb0) ->
-    A = get_kanno(Ke),
-    Vdb1 = use_vars(A#k.us, I, new_vars(A#k.ns, I, Vdb0)),
-    {Es,MaxI,Vdb2} = guard_body(Kb, I+1, Vdb1), 
-    E = guard_expr(Ke, I, Vdb2),
-    {[E|Es],MaxI,Vdb2};
-guard_body(Ke, I, Vdb0) ->
-    A = get_kanno(Ke),
-    Vdb1 = use_vars(A#k.us, I, new_vars(A#k.ns, I, Vdb0)),
-    E = guard_expr(Ke, I, Vdb1),
-    {[E],I,Vdb1}.
-
-%% guard_expr(Call, I, Vdb) -> Expr
-
-guard_expr(#k_test{anno=A,op=Op,args=As}, I, _Vdb) ->
-    #l{ke={test,test_op(Op),atomic_list(As)},i=I,a=A#k.a};
-guard_expr(#k_bif{anno=A,op=Op,args=As,ret=Rs}, I, _Vdb) ->
-    Name = bif_op(Op),
-    Ar = length(As),
-    case is_gc_bif(Name, Ar) of
-	false ->
-	    #l{ke={bif,Name,atomic_list(As),var_list(Rs)},i=I,a=A#k.a};
-	true ->
-	    #l{ke={gc_bif,Name,atomic_list(As),var_list(Rs)},i=I,a=A#k.a}
-    end;
-guard_expr(#k_put{anno=A,arg=Arg,ret=Rs}, I, _Vdb) ->
-    #l{ke={set,var_list(Rs),literal(Arg, [])},i=I,a=A#k.a};
-guard_expr(#k_guard_match{anno=A,body=Kb,ret=Rs}, I, Vdb) ->
-    %% Support for andalso/orelse in guards.
-    %% Work out imported variables which need to be locked.
-    Mdb = vdb_sub(I, I+1, Vdb),
-    M = match(Kb, A#k.us, I+1, [], Mdb),
-    #l{ke={guard_match,M,var_list(Rs)},i=I,vdb=use_vars(A#k.us, I+1, Mdb),a=A#k.a};
-guard_expr(G, I, Vdb) -> guard(G, I, Vdb).
+    #l{ke={protected,T,var_list(Rs)},i=I,a=A#k.a,vdb=Pdb2}.
 
 %% expr(Kexpr, I, Vdb) -> Expr.
 
+expr(#k_test{anno=A,op=Op,args=As}, I, _Vdb) ->
+    #l{ke={test,test_op(Op),atomic_list(As)},i=I,a=A#k.a};
 expr(#k_call{anno=A,op=Op,args=As,ret=Rs}, I, _Vdb) ->
     #l{ke={call,call_op(Op),atomic_list(As),var_list(Rs)},i=I,a=A#k.a};
 expr(#k_enter{anno=A,op=Op,args=As}, I, _Vdb) ->
@@ -176,25 +137,11 @@ expr(#k_guard_match{anno=A,body=Kb,ret=Rs}, I, Vdb) ->
     Mdb = vdb_sub(I, I+1, Vdb),
     M = match(Kb, A#k.us, I+1, [], Mdb),
     #l{ke={guard_match,M,var_list(Rs)},i=I,vdb=use_vars(A#k.us, I+1, Mdb),a=A#k.a};
-expr(#k_try{anno=A,arg=Ka,vars=Vs,body=Kb,evars=Evs,handler=Kh,ret=Rs}, I, Vdb) ->
-    %% Lock variables that are alive before the catch and used afterwards.
-    %% Don't lock variables that are only used inside the try.
-    Tdb0 = vdb_sub(I, I+1, Vdb),
-    %% This is the tricky bit. Lock variables in Arg that are used in
-    %% the body and handler. Add try tag 'variable'.
-    Ab = get_kanno(Kb),
-    Ah = get_kanno(Kh),
-    Tdb1 = use_vars(Ab#k.us, I+3, use_vars(Ah#k.us, I+3, Tdb0)),
-    Tdb2 = vdb_sub(I, I+2, Tdb1),
-    Vnames = fun (Kvar) -> Kvar#k_var.name end,	%Get the variable names
-    {Aes,_,Adb} = body(Ka, I+2, add_var({catch_tag,I+1}, I+1, locked, Tdb2)),
-    {Bes,_,Bdb} = body(Kb, I+4, new_vars(map(Vnames, Vs), I+3, Tdb2)),
-    {Hes,_,Hdb} = body(Kh, I+4, new_vars(map(Vnames, Evs), I+3, Tdb2)),
-    #l{ke={'try',#l{ke={block,Aes},i=I+1,vdb=Adb,a=[]},
-	   var_list(Vs),#l{ke={block,Bes},i=I+3,vdb=Bdb,a=[]},
-	   var_list(Evs),#l{ke={block,Hes},i=I+3,vdb=Hdb,a=[]},
-	   var_list(Rs)},
-       i=I,vdb=Tdb1,a=A#k.a};
+expr(#k_try{}=Try, I, Vdb) ->
+    case is_in_guard() of
+	false -> body_try(Try, I, Vdb);
+	true -> guard(Try, I, Vdb)
+    end;
 expr(#k_try_enter{anno=A,arg=Ka,vars=Vs,body=Kb,evars=Evs,handler=Kh}, I, Vdb) ->
     %% Lock variables that are alive before the catch and used afterwards.
     %% Don't lock variables that are only used inside the try.
@@ -243,6 +190,27 @@ expr(#k_guard_break{anno=A,args=As}, I, Vdb) ->
 expr(#k_return{anno=A,args=As}, I, _Vdb) ->
     #l{ke={return,atomic_list(As)},i=I,a=A#k.a}.
 
+body_try(#k_try{anno=A,arg=Ka,vars=Vs,body=Kb,evars=Evs,handler=Kh,ret=Rs},
+	 I, Vdb) ->
+    %% Lock variables that are alive before the catch and used afterwards.
+    %% Don't lock variables that are only used inside the try.
+    Tdb0 = vdb_sub(I, I+1, Vdb),
+    %% This is the tricky bit. Lock variables in Arg that are used in
+    %% the body and handler. Add try tag 'variable'.
+    Ab = get_kanno(Kb),
+    Ah = get_kanno(Kh),
+    Tdb1 = use_vars(Ab#k.us, I+3, use_vars(Ah#k.us, I+3, Tdb0)),
+    Tdb2 = vdb_sub(I, I+2, Tdb1),
+    Vnames = fun (Kvar) -> Kvar#k_var.name end,	%Get the variable names
+    {Aes,_,Adb} = body(Ka, I+2, add_var({catch_tag,I+1}, I+1, locked, Tdb2)),
+    {Bes,_,Bdb} = body(Kb, I+4, new_vars(map(Vnames, Vs), I+3, Tdb2)),
+    {Hes,_,Hdb} = body(Kh, I+4, new_vars(map(Vnames, Evs), I+3, Tdb2)),
+    #l{ke={'try',#l{ke={block,Aes},i=I+1,vdb=Adb,a=[]},
+	   var_list(Vs),#l{ke={block,Bes},i=I+3,vdb=Bdb,a=[]},
+	   var_list(Evs),#l{ke={block,Hes},i=I+3,vdb=Hdb,a=[]},
+	   var_list(Rs)},
+       i=I,vdb=Tdb1,a=A#k.a}.
+
 %% call_op(Op) -> Op.
 %% bif_op(Op) -> Op.
 %% test_op(Op) -> Op.
@@ -373,7 +341,6 @@ atomic(#k_int{val=I}) -> {integer,I};
 atomic(#k_float{val=F}) -> {float,F};
 atomic(#k_atom{val=N}) -> {atom,N};
 %%atomic(#k_char{val=C}) -> {char,C};
-%%atomic(#k_string{val=S}) -> {string,S};
 atomic(#k_nil{}) -> nil.
 
 atomic_list(Ks) -> [atomic(K) || K <- Ks].
@@ -535,3 +502,7 @@ vdb_sub(Min, Max, Vdb) ->
 	 true -> Vd
       end || {V,F,L}=Vd <- Vdb, F < Min, L >= Min ].
 
+%% is_in_guard() -> true|false.
+
+is_in_guard() ->
+    get(guard_refc) > 0.