From a900b67a1f67fcd982a0aa16452b477c3ac4e264 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 29 Dec 2011 09:37:54 +0100
Subject: sys_core_fold: Remove duplicate optimization

The second clause in opt_case_in_let_2/3 attempts to do the same
optimization as opt_bool_case_redundant/1; it will never succeed.
---
 lib/compiler/src/sys_core_fold.erl | 27 +--------------------------
 1 file changed, 1 insertion(+), 26 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index 5b155398dc..4347ec2a61 100644
--- a/lib/compiler/src/sys_core_fold.erl
+++ b/lib/compiler/src/sys_core_fold.erl
@@ -2065,32 +2065,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
-- 
cgit v1.2.3


From 85f789f22ce07112be08354417b4179ee23427c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 29 Dec 2011 12:18:41 +0100
Subject: sys_core_fold: Simplify opt_bool_not() to cover it completely

In:

   case not Expr of ...

we don't have the information to ascertain that Expr is a boolean
expression. Therefore, add the catch-all clause unconditionally.
---
 lib/compiler/src/sys_core_fold.erl | 26 ++++++++------------------
 1 file changed, 8 insertions(+), 18 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index 4347ec2a61..620b4e8847 100644
--- a/lib/compiler/src/sys_core_fold.erl
+++ b/lib/compiler/src/sys_core_fold.erl
@@ -1747,36 +1747,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}]}.
 
-- 
cgit v1.2.3


From 68651be298a997a22224f53445688a74dc2fab7d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 29 Dec 2011 15:28:32 +0100
Subject: sys_core_fold: Fix opt_guard_try/1

opt_guard_try/1 assumed that it was only operating on guards, and
implicitly assumed that any function call was to BIFs without
any side effects.
---
 lib/compiler/src/sys_core_fold.erl | 24 ++++++++++++++++++------
 1 file changed, 18 insertions(+), 6 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index 620b4e8847..c92ee86e07 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;
-- 
cgit v1.2.3


From e196820fad6b38b3969fc67d0b01853c7ac0d565 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 30 Dec 2011 11:10:26 +0100
Subject: sys_core_fold: Refactor previous_ctx_to_binary/2 to cover it
 completely

---
 lib/compiler/src/sys_core_fold.erl | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index c92ee86e07..6a8fd8980c 100644
--- a/lib/compiler/src/sys_core_fold.erl
+++ b/lib/compiler/src/sys_core_fold.erl
@@ -2589,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
-- 
cgit v1.2.3


From 9123f869e20c38307280838a69758842fc6b9791 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 22 Dec 2011 07:46:49 +0100
Subject: v3_kernel.erl: Remove unused define of EXPENSIVE_BINARY_LIMIT

---
 lib/compiler/src/v3_kernel.erl | 2 --
 1 file changed, 2 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index f2eaa37617..b3153e420f 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).
-- 
cgit v1.2.3


From b53fc3c306f02108f07fa3870bd2555ae8bb17b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Thu, 29 Dec 2011 10:34:37 +0100
Subject: v3_kernel.hrl: Remove unused record #k_string{}

---
 lib/compiler/src/v3_kernel.erl | 2 --
 lib/compiler/src/v3_kernel.hrl | 1 -
 lib/compiler/src/v3_life.erl   | 1 -
 3 files changed, 4 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index b3153e420f..31829ab9bd 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -608,7 +608,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.
@@ -1825,7 +1824,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{}) -> {[],[]};
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..0654f842bb 100644
--- a/lib/compiler/src/v3_life.erl
+++ b/lib/compiler/src/v3_life.erl
@@ -373,7 +373,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].
-- 
cgit v1.2.3


From 1955804aaf831f943941555ab6f46ee22e5a0dac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 27 Dec 2011 11:36:03 +0100
Subject: v3_kernel: Remove clauses that are never executed in arg_val/1

arg_val/1 will never be called for single-valued types, so there
is no need handle these types.
---
 lib/compiler/src/v3_kernel.erl | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index 31829ab9bd..67e22a5662 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -1391,15 +1391,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]
-- 
cgit v1.2.3


From 823f47c8cf3c7a4f32401cae5a2e47916d3593e4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 4 Jan 2012 16:40:31 +0100
Subject: v3_kernel: Handle sequences in guards

A guard with a sequence will cause a crash in v3_codegen. Currently,
it seems that a sequence in a guard will never happen when compiling
from Erlang code, but there are several reasons to fix this problem
anyway:

* There are other compilers that generate Core Erlang code.

* Changes to sys_core_fold (perhaps additional optimizations) may
  cause sequences to be generated in guards.

* A previously uncovered line in sys_core_fold:opt_guard_try/1 will
  now be covered.
---
 lib/compiler/src/v3_kernel.erl | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index 67e22a5662..8bbaf183c8 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -1537,10 +1537,11 @@ uguard_expr(#k_test{anno=A,op=Op,args=As}=Test, Rs, St) ->
     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) ->
+uguard_expr(#k_bif{anno=A,op=Op,args=As}=Bif, Rs, St0) ->
     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};
+    {Brs,St1} = bif_returns(Op, Rs, St0),
+    {Bif#k_bif{anno=#k{us=Used,ns=lit_list_vars(Brs),a=A},ret=Brs},
+     Used,St1};
 uguard_expr(#ivalues{anno=A,args=As}, Rs, St) ->
     Sets = foldr2(fun (V, Arg, Rhs) ->
 			  #iset{anno=A,vars=[V],arg=Arg,body=Rhs}
-- 
cgit v1.2.3


From 6c9fbc473bb7b5a98f0945678bc47bde39a75e8d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 30 Dec 2011 12:17:04 +0100
Subject: v3_kernel: Don't attempt to share identical literals

It is unlikely that sharing literals will actually save any time.
Literals that can be shared are usually small. It is more likely
that maintaining the dictionary of literals will waste time.
---
 lib/compiler/src/v3_kernel.erl | 65 ++++++++++--------------------------------
 1 file changed, 15 insertions(+), 50 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index 8bbaf183c8..0638041950 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -118,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()]) ->
@@ -127,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)}.
@@ -248,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.
@@ -1845,34 +1838,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}
-- 
cgit v1.2.3


From 74c893f90ffc35c52cb4f9c62130a5b05aed5135 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 28 Dec 2011 12:26:08 +0100
Subject: v3_codegen: Eliminate the special case of 'put' without destination

If we let v3_kernel make sure that a 'put' operation always has a
destination register, the special case in v3_codegen is not needed.
---
 lib/compiler/src/v3_codegen.erl | 15 +--------------
 lib/compiler/src/v3_kernel.erl  | 15 +++++++++++----
 2 files changed, 12 insertions(+), 18 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_codegen.erl b/lib/compiler/src/v3_codegen.erl
index 6623485609..0b81cb33c9 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.
diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index 0638041950..67c5764abf 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -1546,11 +1546,12 @@ uguard_expr(#k_match{anno=A,vars=Vs,body=B0}, Rs, St0) ->
     {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) ->
+uguard_expr(Lit, Rs0, St0) ->
     %% Transform literals to puts here.
     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}.
 
 %% uexpr(Expr, Break, State) -> {Expr,[UsedVar],State}.
 %%  Tag an expression with its used variables.
@@ -1670,12 +1671,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]}.
@@ -1732,6 +1734,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.
 
-- 
cgit v1.2.3


From 734f0ce999a174ea1e469c265c6847e91cf0c4cd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 30 Dec 2011 14:41:06 +0100
Subject: v3_kernel: Remove unreached handling of #k_bin_int{} in arg_con/1

arg_con/1 will never be called with #k_bin_int{} argument, since
a #k_bin_int{} is constructed out of #k_bin_seg{} only after
arg_con/1 has been called with a #k_bin_seg{} argument.
---
 lib/compiler/src/v3_kernel.erl | 1 -
 1 file changed, 1 deletion(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index 67c5764abf..43325f4125 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -1373,7 +1373,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.
-- 
cgit v1.2.3


From 70630b0d1e8216bb0d59ae3c66b99ae5df7367b5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 30 Dec 2011 15:47:34 +0100
Subject: v3_kernel: Removed unreached clause for #k_bin_int{} in
 sub_size_var/1

The size field of a #k_bin_int{} is always a literal integer
(#k_int{}); thus there is no way this clause can match.

While we are at it, remove a duplicated call to
select_assert_match_possible/3 in select_bin_int/1.
---
 lib/compiler/src/v3_kernel.erl | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index 43325f4125..de568eef25 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -1112,7 +1112,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
@@ -1254,8 +1253,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
-- 
cgit v1.2.3


From aaa6dd328d6062064295664392e751a6a51ce93e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 30 Dec 2011 16:54:37 +0100
Subject: v3_kernel: Introduce is_in_guard/1

---
 lib/compiler/src/v3_kernel.erl | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index de568eef25..f6f84c38dc 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -1412,9 +1412,10 @@ 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) ->
@@ -1584,10 +1585,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;
@@ -1852,6 +1854,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.
 %%%
-- 
cgit v1.2.3


From cda0f23b62cac146d6afd1467ef96c5d4ad84011 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Fri, 30 Dec 2011 16:54:51 +0100
Subject: v3_kernel: Clean up handling of guards

Handling of guards become a mess when andalso/orelse in guards
were introduced. Clean it up by using common code for most
constructs, regardless of where they occur, and when needed use
is_in_guard/1 to handle guard constructs differently.
---
 lib/compiler/src/v3_kernel.erl | 117 ++++++++++++-----------------------------
 1 file changed, 34 insertions(+), 83 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index f6f84c38dc..71d48e7b0d 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -1418,9 +1418,6 @@ ubody(#ivalues{anno=A,args=As}, {break,_Vbs}, St) ->
 	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
@@ -1437,12 +1434,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.
@@ -1494,66 +1486,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, St0) ->
-    Used = union(op_vars(Op), lit_list_vars(As)),
-    {Brs,St1} = bif_returns(Op, Rs, St0),
-    {Bif#k_bif{anno=#k{us=Used,ns=lit_list_vars(Brs),a=A},ret=Brs},
-     Used,St1};
-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, Rs0, St0) ->
-    %% Transform literals to puts here.
-    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,St1}.
-
-%% 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!
@@ -1606,24 +1553,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
@@ -1769,7 +1719,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),
-- 
cgit v1.2.3


From 084b34086f8f2cf6bc7aa0075f82a487d161cc72 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 3 Jan 2012 09:15:15 +0100
Subject: v3_kernel: Dig out the line number only when generating a warning

---
 lib/compiler/src/v3_kernel.erl | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index 71d48e7b0d..9d1839708f 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -909,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),
@@ -922,15 +921,16 @@ 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) ->
+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 get_kanno(Ke) of
 	[compiler_generated|_] -> St;
 	Anno ->
 	    Line = get_line(Anno),
+	    MatchLine = get_line(MatchAnno),
 	    Warn = case MatchLine of
 		       none -> nomatch_shadow;
 		       _ -> {nomatch_shadow,MatchLine}
-- 
cgit v1.2.3


From 982ce043282cfa9f118f13ce8b3abd989fa0c0f8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Tue, 3 Jan 2012 13:44:17 +0100
Subject: v3_core: Don't put negative line numbers in annotations

In Core Erlang and later passes, compiler-generated code can be
indicated in two different ways: by negative line numbers and by
a 'compiler_generated' annotation.

Simplify the code and improve coverage by turning negative line
numbers positive and adding a 'compiler_generated' annotation in
the v3_core pass. That means that Core Erlang and latter passes
do not have deal with negative line numbers.
---
 lib/compiler/src/sys_core_fold.erl | 35 +++++++++++++----------------------
 lib/compiler/src/v3_codegen.erl    |  2 +-
 lib/compiler/src/v3_core.erl       |  7 ++++++-
 lib/compiler/src/v3_kernel.erl     | 17 +++++++++++------
 4 files changed, 31 insertions(+), 30 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/sys_core_fold.erl b/lib/compiler/src/sys_core_fold.erl
index 6a8fd8980c..4e67639805 100644
--- a/lib/compiler/src/sys_core_fold.erl
+++ b/lib/compiler/src/sys_core_fold.erl
@@ -2741,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.
 
@@ -2770,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 0b81cb33c9..36d35a8122 100644
--- a/lib/compiler/src/v3_codegen.erl
+++ b/lib/compiler/src/v3_codegen.erl
@@ -2054,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 9d1839708f..abe94ad991 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -926,9 +926,11 @@ 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 get_kanno(Ke) of
-	[compiler_generated|_] -> St;
-	Anno ->
+    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
@@ -1830,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).
-- 
cgit v1.2.3


From ecb5470bbcaaead92fdbe43e190b0557ca8f39fa Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B6rn=20Gustavsson?= <bjorn@erlang.org>
Date: Wed, 4 Jan 2012 08:16:27 +0100
Subject: v3_life: Use common code for guards and bodies

---
 lib/compiler/src/v3_life.erl | 96 ++++++++++++++++----------------------------
 1 file changed, 34 insertions(+), 62 deletions(-)

(limited to 'lib/compiler/src')

diff --git a/lib/compiler/src/v3_life.erl b/lib/compiler/src/v3_life.erl
index 0654f842bb..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.
@@ -534,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.
-- 
cgit v1.2.3