compiler: Don't support the no_constant_pool option

The no_constant_pool option was implied by the r11 option. It turns
off the usage of the constant (literal) pool, so that BEAM
instructions that use constants can be loaded in an R11 system.

Since the r11 option has been removed, there is no need to
retain the no_constant_pool option.

10 files changed, 11 insertions, 71 deletions

diff --git a/lib/compiler/src/beam_block.erl b/lib/compiler/src/beam_block.erl
index d4a4ddca8a..9be4888e15 100644
--- a/lib/compiler/src/beam_block.erl
+++ b/lib/compiler/src/beam_block.erl
@@ -140,7 +140,6 @@ collect({move,S,D})          -> {set,[D],[S],move};
 collect({put_list,S1,S2,D})  -> {set,[D],[S1,S2],put_list};
 collect({put_tuple,A,D})     -> {set,[D],[],{put_tuple,A}};
 collect({put,S})             -> {set,[],[S],put};
-collect({put_string,L,S,D})  -> {set,[D],[],{put_string,L,S}};
 collect({get_tuple_element,S,I,D}) -> {set,[D],[S],{get_tuple_element,I}};
 collect({set_tuple_element,S,D,I}) -> {set,[],[S,D],{set_tuple_element,I}};
 collect({get_list,S,D1,D2})  -> {set,[D1,D2],[S],get_list};
@@ -204,7 +203,6 @@ alloc_may_pass({set,_,_,{set_tuple_element,_}}) -> false;
 alloc_may_pass({set,_,_,put_list}) -> false;
 alloc_may_pass({set,_,_,{put_tuple,_}}) -> false;
 alloc_may_pass({set,_,_,put}) -> false;
-alloc_may_pass({set,_,_,{put_string,_,_}}) -> false;
 alloc_may_pass({set,_,_,_}) -> true.
     
 combine_alloc({_,Ns,Nh1,Init}, {_,nostack,Nh2,[]})  ->
diff --git a/lib/compiler/src/beam_flatten.erl b/lib/compiler/src/beam_flatten.erl
index d9de7e2495..92211a9d3d 100644
--- a/lib/compiler/src/beam_flatten.erl
+++ b/lib/compiler/src/beam_flatten.erl
@@ -57,7 +57,6 @@ norm({set,[D],[S],fconv})         -> {fconv,S,D};
 norm({set,[D],[S1,S2],put_list})  -> {put_list,S1,S2,D};
 norm({set,[D],[],{put_tuple,A}})  -> {put_tuple,A,D};
 norm({set,[],[S],put})            -> {put,S};
-norm({set,[D],[],{put_string,L,S}})       -> {put_string,L,S,D};
 norm({set,[D],[S],{get_tuple_element,I}}) -> {get_tuple_element,S,I,D};
 norm({set,[],[S,D],{set_tuple_element,I}}) -> {set_tuple_element,S,D,I};
 norm({set,[D1,D2],[S],get_list})          -> {get_list,S,D1,D2};
diff --git a/lib/compiler/src/beam_jump.erl b/lib/compiler/src/beam_jump.erl
index 739928f411..45902789ee 100644
--- a/lib/compiler/src/beam_jump.erl
+++ b/lib/compiler/src/beam_jump.erl
@@ -452,7 +452,6 @@ is_label_used_in_2({set,_,_,Info}, Lbl) ->
 	{'catch',{f,F}} -> F =:= Lbl;
 	{alloc,_,_} -> false;
 	{put_tuple,_} -> false;
-	{put_string,_,_} -> false;
 	{get_tuple_element,_} -> false;
 	{set_tuple_element,_} -> false;
 	_ when is_atom(Info) -> false
diff --git a/lib/compiler/src/beam_type.erl b/lib/compiler/src/beam_type.erl
index ba903a12b6..5b59e5f2ea 100644
--- a/lib/compiler/src/beam_type.erl
+++ b/lib/compiler/src/beam_type.erl
@@ -253,8 +253,6 @@ flt_need_heap_2({set,_,_,{put_tuple,_}}, H, Fl) ->
     {[],H+1,Fl};
 flt_need_heap_2({set,_,_,put}, H, Fl) ->
     {[],H+1,Fl};
-flt_need_heap_2({set,_,_,{put_string,L,_Str}}, H, Fl) ->
-    {[],H+2*L,Fl};
 %% Then the "neutral" instructions. We just pass them.
 flt_need_heap_2({set,[{fr,_}],_,_}, H, Fl) ->
     {[],H,Fl};
diff --git a/lib/compiler/src/compile.erl b/lib/compiler/src/compile.erl
index 7194a10b14..eaec5a6d78 100644
--- a/lib/compiler/src/compile.erl
+++ b/lib/compiler/src/compile.erl
@@ -588,7 +588,7 @@ core_passes() ->
 
 kernel_passes() ->
     %% Destructive setelement/3 optimization and core lint.
-    [{unless,no_constant_pool,?pass(core_dsetel_module)}, %Not safe without constant pool.
+    [?pass(core_dsetel_module),
      {iff,dsetel,{listing,"dsetel"}},
 
      {iff,clint,?pass(core_lint_module)},
diff --git a/lib/compiler/src/sys_core_dsetel.erl b/lib/compiler/src/sys_core_dsetel.erl
index c38eab7b42..cc2977dafd 100644
--- a/lib/compiler/src/sys_core_dsetel.erl
+++ b/lib/compiler/src/sys_core_dsetel.erl
@@ -57,8 +57,6 @@
 %% if X1 is used exactly once.
 %% Thus, we need to track variable usage.
 %%
-%% NOTE: This pass must NOT be used if the no_constant_pool option is used.
-%%
 
 -module(sys_core_dsetel).
 
diff --git a/lib/compiler/src/v3_codegen.erl b/lib/compiler/src/v3_codegen.erl
index 83113d1652..64a53c400e 100644
--- a/lib/compiler/src/v3_codegen.erl
+++ b/lib/compiler/src/v3_codegen.erl
@@ -209,7 +209,6 @@ need_heap_1(#l{ke={set,_,Val}}, H) ->
     {[],H + case Val of
 		{cons,_} -> 2;
 		{tuple,Es} -> 1 + length(Es);
-		{string,S} -> 2 * length(S);
 		_Other -> 0
 	    end};
 need_heap_1(#l{ke={bif,dsetelement,_As,_Rs},i=I}, H) ->
@@ -1424,8 +1423,6 @@ set_cg([{var,R}], Con, Le, Vdb, Bef, St) ->
 		  [{put_tuple,length(Es),Ret}] ++ cg_build_args(Es, Bef);
 	      {var,V} ->	  % Normally removed by kernel optimizer.
 		  [{move,fetch_var(V, Int),Ret}];
-	      {string,Str} = String ->
-		  [{put_string,length(Str),String,Ret}];
 	      Other ->
 		  [{move,Other,Ret}]
 	  end,
diff --git a/lib/compiler/src/v3_kernel.erl b/lib/compiler/src/v3_kernel.erl
index 8568071e57..9ee3dee5e0 100644
--- a/lib/compiler/src/v3_kernel.erl
+++ b/lib/compiler/src/v3_kernel.erl
@@ -126,12 +126,8 @@ copy_anno(Kdst, Ksrc) ->
 -spec module(cerl:c_module(), [compile:option()]) ->
 	{'ok', #k_mdef{}, [warning()]}.
 
-module(#c_module{anno=A,name=M,exports=Es,attrs=As,defs=Fs}, Options) ->
-    Lit = case member(no_constant_pool, Options) of
-	      true -> no;
-	      false -> dict:new()
-	  end,
-    St0 = #kern{lit=Lit},
+module(#c_module{anno=A,name=M,exports=Es,attrs=As,defs=Fs}, _Options) ->
+    St0 = #kern{lit=dict:new()},
     {Kfs,St} = mapfoldl(fun function/2, St0, Fs),
     Kes = map(fun (#c_var{name={_,_}=Fname}) -> Fname end, Es),
     Kas = map(fun ({#c_literal{val=N},V}) ->
@@ -240,11 +236,6 @@ 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{anno=A,val=Lit}, Sub, #kern{lit=no}=St) ->
-    %% No constant pools for compatibility with a previous version.
-    %% Fully expand the literal.
-    Core = expand_literal(Lit, A),
-    expr(Core, Sub, St);
 expr(#c_literal{}=Lit, Sub, St) ->
     Core = handle_literal(Lit),
     expr(Core, Sub, St);
@@ -265,9 +256,6 @@ expr(#k_float{}=V, _Sub, St) ->
     {V,[],St};
 expr(#k_atom{}=V, _Sub, St) ->
     {V,[],St};
-expr(#k_string{}=V, _Sub, St) ->
-    %% Only for compatibility with a previous version.
-    {V,[],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.
@@ -980,11 +968,6 @@ match_var([U|Us], Cs0, Def, St) ->
 %%  according to type, the order is really irrelevant but tries to be
 %%  smart.
 
-match_con(Us, Cs0, Def, #kern{lit=no}=St) ->
-    %% No constant pool (for compatibility with R11B).
-    %% We must expand literals.
-    Cs = [expand_pat_lit_clause(C, true) || C <- Cs0],
-    match_con_1(Us, Cs, Def, St);
 match_con(Us, [C], Def, St) ->
     %% There is only one clause. We can keep literal tuples and
     %% lists, but we must convert []/integer/float/atom literals
@@ -1783,7 +1766,6 @@ lit_vars(#k_int{}) -> [];
 lit_vars(#k_float{}) -> [];
 lit_vars(#k_atom{}) -> [];
 %%lit_vars(#k_char{}) -> [];
-lit_vars(#k_string{}) -> [];
 lit_vars(#k_nil{}) -> [];
 lit_vars(#k_cons{hd=H,tl=T}) ->
     union(lit_vars(H), lit_vars(T));
@@ -1845,48 +1827,20 @@ 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};
-	_ ->
-	    expand_literal(V, 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}
     end.
 
-%% expand_literal(Literal, Anno) -> CoreTerm | KernelTerm
-%%  Fully expand the literal. Atomic terms such as integers are directly
-%%  translated to the Kernel Erlang format, while complex terms are kept
-%%  in the Core Erlang format (but the content is recursively processed).
-
-expand_literal([H|T]=V, A) when is_integer(H), 0 =< H, H =< 255 ->
-    case is_print_char_list(T) of
-	false ->
-	    #c_cons{anno=A,hd=#k_int{anno=A,val=H},tl=expand_literal(T, A)};
-	true ->
-	    #k_string{anno=A,val=V}
-    end;
-expand_literal([H|T], A) ->
-    #c_cons{anno=A,hd=expand_literal(H, A),tl=expand_literal(T, A)};
-expand_literal([], A) ->
-    #k_nil{anno=A};
-expand_literal(V, A) when is_tuple(V) ->
-    #c_tuple{anno=A,es=expand_literal_list(tuple_to_list(V), A)};
-expand_literal(V, A) when is_integer(V) ->
-    #k_int{anno=A,val=V};
-expand_literal(V, A) when is_float(V) ->
-    #k_float{anno=A,val=V};
-expand_literal(V, A) when is_atom(V) ->
-    #k_atom{anno=A,val=V}.
-
-expand_literal_list([H|T], A) ->
-    [expand_literal(H, A)|expand_literal_list(T, A)];
-expand_literal_list([], _) -> [].
-
-is_print_char_list([H|T]) when is_integer(H), 0 =< H, H =< 255 ->
-    is_print_char_list(T);
-is_print_char_list([]) -> true;
-is_print_char_list(_) -> false.
-
 make_list(Es) ->
     foldr(fun(E, Acc) ->
  		  #c_cons{hd=E,tl=Acc}
diff --git a/lib/compiler/src/v3_kernel_pp.erl b/lib/compiler/src/v3_kernel_pp.erl
index b1ca907d11..40f1efe1f2 100644
--- a/lib/compiler/src/v3_kernel_pp.erl
+++ b/lib/compiler/src/v3_kernel_pp.erl
@@ -80,7 +80,6 @@ format_1(#k_atom{val=A}, _Ctxt) -> core_atom(A);
 format_1(#k_float{val=F}, _Ctxt) -> float_to_list(F);
 format_1(#k_int{val=I}, _Ctxt) -> integer_to_list(I);
 format_1(#k_nil{}, _Ctxt) -> "[]";
-format_1(#k_string{val=S}, _Ctxt) -> io_lib:write_string(S);
 format_1(#k_var{name=V}, _Ctxt) ->
     if is_atom(V) ->
 	    case atom_to_list(V) of
diff --git a/lib/compiler/src/v3_life.erl b/lib/compiler/src/v3_life.erl
index 8e6b153d57..9fda37530b 100644
--- a/lib/compiler/src/v3_life.erl
+++ b/lib/compiler/src/v3_life.erl
@@ -418,7 +418,6 @@ literal(#k_int{val=I}, _) -> {integer,I};
 literal(#k_float{val=F}, _) -> {float,F};
 literal(#k_atom{val=N}, _) -> {atom,N};
 %%literal(#k_char{val=C}, _) -> {char,C};
-literal(#k_string{val=S}, _) -> {string,S};
 literal(#k_nil{}, _) -> nil;
 literal(#k_cons{hd=H,tl=T}, Ctxt) ->
     {cons,[literal(H, Ctxt),literal(T, Ctxt)]};
@@ -443,7 +442,6 @@ literal2(#k_int{val=I}, _) -> {integer,I};
 literal2(#k_float{val=F}, _) -> {float,F};
 literal2(#k_atom{val=N}, _) -> {atom,N};
 %%literal2(#k_char{val=C}, _) -> {char,C};
-literal2(#k_string{val=S}, _) -> {string,S};
 literal2(#k_nil{}, _) -> nil;
 literal2(#k_cons{hd=H,tl=T}, Ctxt) ->
     {cons,[literal2(H, Ctxt),literal2(T, Ctxt)]};